GherkinParam::onReconfigure() - Code Metrics - Inspection of "Support for handling invalid parameters (#23)" - edno/codeception-gherkin-param - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#26)

by Greg

created 2020-02-04 22:12 UTC

GherkinParam::onReconfigure() A

↳ Parent: GherkinParam

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

/**
 * 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;
use \RuntimeException;
use \Codeception\Exception\ExtensionException;
use \Codeception\Configuration;
use \Codeception\Step;

class GherkinParam extends \Codeception\Module
{
 
  /**
   * @var boolean Flag to enable exception (prioritised over $nullable=true)
   * false: no exception thrown if parameter invalid, instead replacement value is parameter {{name}} 
   * true: exception thrown if parameter invalid
   */
  private $throwException = false;

  /**
   * @var boolean Flag to null invalid parameter (incompatible with $throwException=true)
   * true: if parameter invalid then replacement value will be null
   * false: default behaviour, ie replacement value is parameter {{name}} 
   */
  private $nullable = false;

  protected $config = ['onErrorThrowException', 'onErrorNull'];

  protected $requiredFields = [];

  /**
   * @var array List events to listen to
   */
  public static $events = [
    //run before any suite
    'suite.before' => 'beforeSuite',
    //run before any steps
    'step.before' => 'beforeStep'
  ];

  /**
   * @var array Current test suite config
   */
  private static $suiteConfig;

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

  /**
   * Initialize module configuration
   */
  final public function _initialize() 
  {
    if (isset($this->config['onErrorThrowException'])) {
      $this->throwException = (bool) $this->config['onErrorThrowException'];
    }

    if (isset($this->config['onErrorNull'])) {
      $this->nullable = (bool) $this->config['onErrorNull'];
    }
  }

  /**
   * Dynamic module reconfiguration
   */
  final public function onReconfigure()
  {
    $this->_initialize();
  }

  /**
   * Parse param and replace {{.*}} by its Fixtures::get() value if exists
   *
   * @param string $param
   *
   * @return \mixed|null Returns parameter's value if exists, else parameter's name
   */
  final protected function getValueFromParam(string $param)
  {
    if (preg_match_all(self::$regEx['match'], $param, $matches)) {
      try {
        $values = [];
        $matches = $matches[0]; // override for readability
        foreach ($matches as $variable)
        {
          $variable = trim(preg_filter(self::$regEx['filter'], '', $variable));
          // config case
          if (preg_match(self::$regEx['config'], $variable)) {
            $values[] = $this->getValueFromConfig($variable);
          } 
          // array case
          elseif (preg_match(self::$regEx['array'], $variable)) {
            try {
              $values[] = $this->getValueFromArray($variable);
            } catch(RuntimeException $e) {
              if ($this->throwException) throw new GherkinParamException();
              if ($this->nullable) $values[] = null;
            }
          } 
          // normal case
          else {
            try {
              $values[] = Fixtures::get($variable);
            } catch(RuntimeException $e) {
              if ($this->throwException) throw new GherkinParamException();
              if ($this->nullable) $values[] = null;
            }
          }
          // if machting value return is not found (null)
          if (is_null(end($values))) {
            if ($this->throwException) throw new GherkinParamException();
          }
        }

        // array str_replace cannot be used 
        // due to the default behavior when `search` and `replace` arrays size mismatch
        $param = $this->mapParametersToValues($matches, $values, $param);

      } catch(GherkinParamException $e) {
        // only active if throwException setting is true
        throw new ExtensionException($this, "Incorrect parameter name ${param}, or not initialized");
      }
    
    }

    return $param;
  }

  /**
   * Replace parameters' matches by corresponding values
   *
   * @param array $matches
   * @param array $values
   * @param string $param
   *
   * @return \mixed|null Returns parameter's value if exists, else parameter {{name}}
   */  
  //TODO: pass param ref to function (&) [performance]
  final private function mapParametersToValues(array $matches, array $values, string $param)
  {
    //TODO: move count() into separate variable [performance]
    for ($i=0; $i<count($matches); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
      $search = $matches[$i];
      if (\is_string($search)) { // if null then skip
        if (isset($values[$i])) {
          $replacement = $values[$i];
          if (\is_array($replacement)) { 
            // case of replacement is an array (case of config param), ie param does not exists
            if ($this->throwException) throw new GherkinParamException();
            if ($this->nullable) $param = null;
            break;
          }
          //TODO: replace str_replace by strtr (performance)
          $param = \str_replace($search, $replacement, $param);
        } else {
          if ($this->throwException) throw new GherkinParamException();
          if ($this->nullable) $param = null;
        }
      } else {
        if ($this->nullable) $param = null;
        break;
      }
    }
    return $param;
  }

  /**
   * Retrieve param value from current suite config
   *
   * @param string $param
   *
   * @return \mixed|null Returns parameter's value if exists, else null
   */
  //TODO: pass param ref to function (&) [performance]
  final protected function getValueFromConfig(string $param)
  {
    $value = null;
    $config = self::$suiteConfig;

    preg_match_all(self::$regEx['config'], $param, $args, PREG_PATTERN_ORDER);
    foreach ($args[1] as $arg) {
      if (array_key_exists($arg, $config)) {
        $value = $config[$arg];
        if (is_array($value)) {
          $config = $value;
        } else {
          break;
        }
      }
    }
    return $value;
  }

  /**
   * Retrieve param value from array in Fixtures
   *
   * @param string $param
   *
   * @return \mixed|null Returns parameter's value if exists, else null
   */
  //TODO: pass param ref to function (&) [performance]
  final protected function getValueFromArray(string $param)
  {
    $value = null;

    preg_match_all(self::$regEx['array'], $param, $args);
    $array = Fixtures::get($args['var'][0]);
    if (array_key_exists($args['key'][0], $array)) {
        $value = $array[$args['key'][0]];
    }
    return $value;
  }

  /**
   * Capture suite's config before any execution
   *
   * @param array $settings
   * @return void
   *
   * @codeCoverageIgnore
   * @ignore Codeception specific
   */
  final public function _beforeSuite($settings = [])
  {
    self::$suiteConfig = $settings;
  }

  /**
   * Parse scenario's step before execution
   *
   * @param \Codeception\Step $step
   * @return void
   */
  final public function _beforeStep(Step $step)
  {
    // 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}} |
        $prop = new ReflectionProperty(get_class($arg), 'table');
        $prop->setAccessible(true);
        $table = $prop->getValue($arg);
        foreach($table as $i => $row) {
          foreach ($row as $j => $cell) {
            $val = $this->getValueFromParam($cell);
            $table[$i][$j] = $val ? $val : null; // issue TableNode does not support `null` values in table
          }
        }
        $prop->setValue($arg, $table);
        $prop->setAccessible(false);
        $args[$index] = $arg;
      } elseif (is_array($arg)) {
        foreach ($arg as $k => $v) {
          if (is_string($v)) {
             $args[$index][$k] = $this->getValueFromParam($v);
          }
        }
      }
    }
    // set new arguments value
    $refArgs->setValue($step, $args);
  }

}


1			<?php
2
3			declare(strict_types=1);
4
5			/**
6			* Before step hook that provide parameter syntax notation
7			* for accessing fixture data between Gherkin steps/tests
8			* example:
9			* I see "{{param}}"
10			* {{param}} will be replaced by the value of Fixtures::get('param')
11			*
12			*/
13			namespace Codeception\Extension;
14
15			use \Codeception\Util\Fixtures;
16			use \Behat\Gherkin\Node\TableNode;
17			use \ReflectionProperty;
18			use \RuntimeException;
19			use \Codeception\Exception\ExtensionException;
20			use \Codeception\Configuration;
21			use \Codeception\Step;
22
23			class GherkinParam extends \Codeception\Module
24			{
25
26			/**
27			* @var boolean Flag to enable exception (prioritised over $nullable=true)
28			* false: no exception thrown if parameter invalid, instead replacement value is parameter {{name}}
29			* true: exception thrown if parameter invalid
30			*/
31			private $throwException = false;
32
33			/**
34			* @var boolean Flag to null invalid parameter (incompatible with $throwException=true)
35			* true: if parameter invalid then replacement value will be null
36			* false: default behaviour, ie replacement value is parameter {{name}}
37			*/
38			private $nullable = false;
39
40			protected $config = ['onErrorThrowException', 'onErrorNull'];
41
42			protected $requiredFields = [];
43
44			/**
45			* @var array List events to listen to
46			*/
47			public static $events = [
48			//run before any suite
49			'suite.before' => 'beforeSuite',
50			//run before any steps
51			'step.before' => 'beforeStep'
52			];
53
54			/**
55			* @var array Current test suite config
56			*/
57			private static $suiteConfig;
58
59			/**
60			* @var array RegExp for parsing steps
61			*/
62			private static $regEx = [
63			'match' => '/{{\s?[A-z0-9_:-<>]+\s?}}/',
64			'filter' => '/[{}]/',
65			'config' => '/(?:^config)?:([A-z0-9_-]+)+(?=:\|$)/',
66			'array' => '/^(?P<var>[A-z0-9_-]+)(?:\[(?P<key>.+)])$/'
67			];
68
69			/**
70			* Initialize module configuration
71			*/
72			final public function _initialize()
73			{
74			if (isset($this->config['onErrorThrowException'])) {
75			$this->throwException = (bool) $this->config['onErrorThrowException'];
76			}
77
78			if (isset($this->config['onErrorNull'])) {
79			$this->nullable = (bool) $this->config['onErrorNull'];
80			}
81			}
82
83			/**
84			* Dynamic module reconfiguration
85			*/
86			final public function onReconfigure()
87			{
88			$this->_initialize();
89			}
90
91			/**
92			* Parse param and replace {{.*}} by its Fixtures::get() value if exists
93			*
94			* @param string $param
95			*
96			* @return \mixed\|null Returns parameter's value if exists, else parameter's name
97			*/
98			final protected function getValueFromParam(string $param)
99			{
100			if (preg_match_all(self::$regEx['match'], $param, $matches)) {
101			try {
102			$values = [];
103			$matches = $matches[0]; // override for readability
104			foreach ($matches as $variable)
105			{
106			$variable = trim(preg_filter(self::$regEx['filter'], '', $variable));
107			// config case
108			if (preg_match(self::$regEx['config'], $variable)) {
109			$values[] = $this->getValueFromConfig($variable);
110			}
111			// array case
112			elseif (preg_match(self::$regEx['array'], $variable)) {
113			try {
114			$values[] = $this->getValueFromArray($variable);
115			} catch(RuntimeException $e) {
116			if ($this->throwException) throw new GherkinParamException();
117			if ($this->nullable) $values[] = null;
118			}
119			}
120			// normal case
121			else {
122			try {
123			$values[] = Fixtures::get($variable);
124			} catch(RuntimeException $e) {
125			if ($this->throwException) throw new GherkinParamException();
126			if ($this->nullable) $values[] = null;
127			}
128			}
129			// if machting value return is not found (null)
130			if (is_null(end($values))) {
131			if ($this->throwException) throw new GherkinParamException();
132			}
133			}
134
135			// array str_replace cannot be used
136			// due to the default behavior when `search` and `replace` arrays size mismatch
137			$param = $this->mapParametersToValues($matches, $values, $param);
138
139			} catch(GherkinParamException $e) {
140			// only active if throwException setting is true
141			throw new ExtensionException($this, "Incorrect parameter name ${param}, or not initialized");
142			}
143
144			}
145
146			return $param;
147			}
148
149			/**
150			* Replace parameters' matches by corresponding values
151			*
152			* @param array $matches
153			* @param array $values
154			* @param string $param
155			*
156			* @return \mixed\|null Returns parameter's value if exists, else parameter {{name}}
157			*/
158			//TODO: pass param ref to function (&) [performance]
159			final private function mapParametersToValues(array $matches, array $values, string $param)
160			{
161			//TODO: move count() into separate variable [performance]
162			for ($i=0; $i<count($matches); $i++) {
			0 ignored issues – show Performance Best Practice introduced 2020-02-04 21:44 UTC by Report Bug Copy Issue Report It seems like you are calling the size function `count()` as part of the test condition. You might want to compute the size beforehand, and not on each iteration. If the size of the collection does not change during the iteration, it is generally a good practice to compute it beforehand, and not on each iteration: for ($i=0; $i<count($array); $i++) { // calls count() on each iteration } // Better for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once } Loading history...
163			$search = $matches[$i];
164			if (\is_string($search)) { // if null then skip
165			if (isset($values[$i])) {
166			$replacement = $values[$i];
167			if (\is_array($replacement)) {
168			// case of replacement is an array (case of config param), ie param does not exists
169			if ($this->throwException) throw new GherkinParamException();
170			if ($this->nullable) $param = null;
171			break;
172			}
173			//TODO: replace str_replace by strtr (performance)
174			$param = \str_replace($search, $replacement, $param);
175			} else {
176			if ($this->throwException) throw new GherkinParamException();
177			if ($this->nullable) $param = null;
178			}
179			} else {
180			if ($this->nullable) $param = null;
181			break;
182			}
183			}
184			return $param;
185			}
186
187			/**
188			* Retrieve param value from current suite config
189			*
190			* @param string $param
191			*
192			* @return \mixed\|null Returns parameter's value if exists, else null
193			*/
194			//TODO: pass param ref to function (&) [performance]
195			final protected function getValueFromConfig(string $param)
196			{
197			$value = null;
198			$config = self::$suiteConfig;
199
200			preg_match_all(self::$regEx['config'], $param, $args, PREG_PATTERN_ORDER);
201			foreach ($args[1] as $arg) {
202			if (array_key_exists($arg, $config)) {
203			$value = $config[$arg];
204			if (is_array($value)) {
205			$config = $value;
206			} else {
207			break;
208			}
209			}
210			}
211			return $value;
212			}
213
214			/**
215			* Retrieve param value from array in Fixtures
216			*
217			* @param string $param
218			*
219			* @return \mixed\|null Returns parameter's value if exists, else null
220			*/
221			//TODO: pass param ref to function (&) [performance]
222			final protected function getValueFromArray(string $param)
223			{
224			$value = null;
225
226			preg_match_all(self::$regEx['array'], $param, $args);
227			$array = Fixtures::get($args['var'][0]);
228			if (array_key_exists($args['key'][0], $array)) {
229			$value = $array[$args['key'][0]];
230			}
231			return $value;
232			}
233
234			/**
235			* Capture suite's config before any execution
236			*
237			* @param array $settings
238			* @return void
239			*
240			* @codeCoverageIgnore
241			* @ignore Codeception specific
242			*/
243			final public function _beforeSuite($settings = [])
244			{
245			self::$suiteConfig = $settings;
246			}
247
248			/**
249			* Parse scenario's step before execution
250			*
251			* @param \Codeception\Step $step
252			* @return void
253			*/
254			final public function _beforeStep(Step $step)
255			{
256			// access to the protected property using reflection
257			$refArgs = new ReflectionProperty(get_class($step), 'arguments');
258			// change property accessibility to public
259			$refArgs->setAccessible(true);
260			// retrieve 'arguments' value
261			$args = $refArgs->getValue($step);
262			foreach ($args as $index => $arg) {
263			if (is_string($arg)) {
264			// case if arg is a string
265			// e.g. I see "{{param}}"
266			$args[$index] = $this->getValueFromParam($arg);
267			} elseif (is_a($arg, '\Behat\Gherkin\Node\TableNode')) {
268			// case if arg is a table
269			// e.g. I see :
270			// \| paramater \|
271			// \| {{param}} \|
272			$prop = new ReflectionProperty(get_class($arg), 'table');
273			$prop->setAccessible(true);
274			$table = $prop->getValue($arg);
275			foreach($table as $i => $row) {
276			foreach ($row as $j => $cell) {
277			$val = $this->getValueFromParam($cell);
278			$table[$i][$j] = $val ? $val : null; // issue TableNode does not support `null` values in table
279			}
280			}
281			$prop->setValue($arg, $table);
282			$prop->setAccessible(false);
283			$args[$index] = $arg;
284			} elseif (is_array($arg)) {
285			foreach ($arg as $k => $v) {
286			if (is_string($v)) {
287			$args[$index][$k] = $this->getValueFromParam($v);
288			}
289			}
290			}
291			}
292			// set new arguments value
293			$refArgs->setValue($step, $args);
294			}
295
296			}
297

edno / codeception-gherkin-param

Pull Request — master (#26)

GherkinParam::onReconfigure() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like