DrushDriver::userCreate() - Code Metrics - Inspection of "Merge pull request #184 from xaqrox/drush-uid" - jhedstrom/DrupalDriver - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( acf9c1...2febee )

by Jonathan

created 2018-04-18 17:16 UTC

DrushDriver::userCreate() B

↳ Parent: DrushDriver

Complexity

Conditions	5
Paths	6

Size

Total Lines	18
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	18
rs	8.8571
c	0
b	0
f	0
cc	5
eloc	12
nc	6
nop	1

<?php

namespace Drupal\Driver;

use Drupal\Component\Utility\Random;
use Drupal\Driver\Exception\BootstrapException;

use Symfony\Component\Process\Process;

/**
 * Implements DriverInterface.
 */
class DrushDriver extends BaseDriver {
  /**
   * Store a drush alias for tests requiring shell access.
   *
   * @var string
   */
  public $alias;

  /**
   * Stores the root path to a Drupal installation.
   *
   * This is an alternative to using drush aliases.
   *
   * @var string
   */
  public $root;

  /**
   * Store the path to drush binary.
   *
   * @var string
   */
  public $binary;

  /**
   * Track bootstrapping.
   *
   * @var bool
   */
  private $bootstrapped = FALSE;

  /**
   * Random generator.
   *
   * @var \Drupal\Component\Utility\Random
   */
  private $random;

  /**
   * Global arguments or options for drush commands.
   *
   * @var string
   */
  private $arguments = '';

  /**
   * Tracks legacy drush.
   *
   * @var bool
   */
  protected static $isLegacyDrush;

  /**
   * Set drush alias or root path.
   *
   * @param string $alias
   *   A drush alias.
   * @param string $root_path
   *   The root path of the Drupal install. This is an alternative to using
   *   aliases.
   * @param string $binary
   *   The path to the drush binary.
   * @param \Drupal\Component\Utility\Random $random
   *   Random generator.
   *
   * @throws \Drupal\Driver\Exception\BootstrapException
   *   Thrown when a required parameter is missing.
   */
  public function __construct($alias = NULL, $root_path = NULL, $binary = 'drush', Random $random = NULL) {
    if (!empty($alias)) {
      // Trim off the '@' symbol if it has been added.
      $alias = ltrim($alias, '@');

      $this->alias = $alias;
    }
    elseif (!empty($root_path)) {
      $this->root = realpath($root_path);
    }
    else {
      throw new BootstrapException('A drush alias or root path is required.');
    }

    $this->binary = $binary;

    if (!isset($random)) {
      $random = new Random();
    }
    $this->random = $random;
  }

  /**
   * {@inheritdoc}
   */
  public function getRandom() {
    return $this->random;
  }

  /**
   * {@inheritdoc}
   */
  public function bootstrap() {
    // Check that the given alias works.
    // @todo check that this is a functioning alias.
    // See http://drupal.org/node/1615450
    if (!isset($this->alias) && !isset($this->root)) {
      throw new BootstrapException('A drush alias or root path is required.');
    }

    // Determine if drush version is legacy.
    if (!isset(self::$isLegacyDrush)) {
      self::$isLegacyDrush = $this->isLegacyDrush();
    }

    $this->bootstrapped = TRUE;
  }

  /**
   * Determine if drush is a legacy version.
   *
   * @return bool
   *   Returns TRUE if drush is older than drush 9.
   */
  protected function isLegacyDrush() {
    try {
      // Try for a drush 9 version.
      $version = trim($this->drush('version', [], ['format' => 'string']));
      return version_compare($version, '9', '<=');
    }
    catch (\RuntimeException $e) {
      // The version of drush is old enough that only `--version` was available,
      // so this is a legacy version.
      return TRUE;
    }
  }

  /**
   * {@inheritdoc}
   */
  public function isBootstrapped() {
    return $this->bootstrapped;
  }

  /**
   * {@inheritdoc}
   */
  public function userCreate(\stdClass $user) {
    $arguments = array(
      sprintf('"%s"', $user->name),
    );
    $options = array(
      'password' => $user->pass,
      'mail' => $user->mail,
    );
    $result = $this->drush('user-create', $arguments, $options);
    if ($uid = $this->parseUserId($result)) {
      $user->uid = $uid;
    }
    if (isset($user->roles) && is_array($user->roles)) {
      foreach ($user->roles as $role) {
        $this->userAddRole($user, $role);
      }
    }
  }

  /**
   * Parse user id from drush user-information output.
   */
  protected function parseUserId($info) {
    // Find the row containing "User ID : xxx".
    preg_match('/User ID\s+:\s+\d+/', $info, $matches);
    if (!empty($matches)) {
      // Extract the ID from the row.
      list(, $uid) = explode(':', $matches[0]);
      return (int) $uid;
    }
  }

  /**
   * {@inheritdoc}
   */
  public function userDelete(\stdClass $user) {
    $arguments = array(sprintf('"%s"', $user->name));
    $options = array(
      'yes' => NULL,
      'delete-content' => NULL,
    );
    $this->drush('user-cancel', $arguments, $options);
  }

  /**
   * {@inheritdoc}
   */
  public function userAddRole(\stdClass $user, $role) {
    $arguments = array(
      sprintf('"%s"', $role),
      sprintf('"%s"', $user->name),
    );
    $this->drush('user-add-role', $arguments);
  }

  /**
   * {@inheritdoc}
   */
  public function fetchWatchdog($count = 10, $type = NULL, $severity = NULL) {
    $options = array(
      'count' => $count,
      'type' => $type,
      'severity' => $severity,
    );
    return $this->drush('watchdog-show', array(), $options);
  }

  /**
   * {@inheritdoc}
   */
  public function clearCache($type = 'all') {
    $type = array($type);
    return $this->drush('cache-clear', $type, array());
  }

  /**
   * {@inheritdoc}
   */
  public function clearStaticCaches() {
    // The drush driver does each operation as a separate request;
    // therefore, 'clearStaticCaches' can be a no-op.
  }

  /**
   * Decodes JSON object returned by Drush.
   *
   * It will clean up any junk that may have appeared before or after the
   * JSON object. This can happen with remote Drush aliases.
   *
   * @param string $output
   *   The output from Drush.
   *
   * @return object
   *   The decoded JSON object.
   */
  protected function decodeJsonObject($output) {
    // Remove anything before the first '{'.
    $output = preg_replace('/^[^\{]*/', '', $output);
    // Remove anything after the last '}'.
    $output = preg_replace('/[^\}]*$/s', '', $output);
    return json_decode($output);
  }

  /**
   * {@inheritdoc}
   */
  public function createNode($node) {
    // Look up author by name.
    if (isset($node->author)) {
      $user_info = $this->drush('user-information', array(sprintf('"%s"', $node->author)));
      if ($uid = $this->parseUserId($user_info)) {
        $node->uid = $uid;
      }
    }
    $result = $this->drush('behat', array('create-node', escapeshellarg(json_encode($node))), array());
    return $this->decodeJsonObject($result);
  }

  /**
   * {@inheritdoc}
   */
  public function nodeDelete($node) {
    $this->drush('behat', array('delete-node', escapeshellarg(json_encode($node))), array());
  }

  /**
   * {@inheritdoc}
   */
  public function createTerm(\stdClass $term) {
    $result = $this->drush('behat', array('create-term', escapeshellarg(json_encode($term))), array());
    return $this->decodeJsonObject($result);
  }

  /**
   * {@inheritdoc}
   */
  public function termDelete(\stdClass $term) {
    $this->drush('behat', array('delete-term', escapeshellarg(json_encode($term))), array());
  }

  /**
   * {@inheritdoc}
   */
  public function isField($entity_type, $field_name) {
    // If the Behat Drush Endpoint is not installed on the site-under-test,
    // then the drush() method will throw an exception. In this instance, we
    // want to treat all potential fields as non-fields.  This allows the
    // Drush Driver to work with certain built-in Drush capabilities (e.g.
    // creating users) even if the Behat Drush Endpoint is not available.
    try {
      $value = array($entity_type, $field_name);
      $arguments = array('is-field', escapeshellarg(json_encode($value)));
      $result = $this->drush('behat', $arguments, array());
      return strpos($result, "true\n") !== FALSE;
    }
    catch (\Exception $e) {
      return FALSE;
    }
  }

  /**
   * Sets common drush arguments or options.
   *
   * @param string $arguments
   *   Global arguments to add to every drush command.
   */
  public function setArguments($arguments) {
    $this->arguments = $arguments;
  }

  /**
   * Get common drush arguments.
   */
  public function getArguments() {
    return $this->arguments;
  }

  /**
   * Parse arguments into a string.
   *
   * @param array $arguments
   *   An array of argument/option names to values.
   *
   * @return string
   *   The parsed arguments.
   */
  protected static function parseArguments(array $arguments) {
    $string = '';
    foreach ($arguments as $name => $value) {
      if (is_null($value)) {
        $string .= ' --' . $name;
      }
      else {
        $string .= ' --' . $name . '=' . $value;
      }
    }
    return $string;
  }

  /**
   * Execute a drush command.
   */
  public function drush($command, array $arguments = array(), array $options = array()) {
    $arguments = implode(' ', $arguments);

    // Disable colored output from drush.
    if (isset(static::$isLegacyDrush) && static::$isLegacyDrush) {
      $options['nocolor'] = TRUE;
    }
    else {
      $options['no-ansi'] = NULL;
    }
    $string_options = $this->parseArguments($options);

    $alias = isset($this->alias) ? "@{$this->alias}" : '--root=' . $this->root;

    // Add any global arguments.
    $global = $this->getArguments();

    $process = new Process("{$this->binary} {$alias} {$string_options} {$global} {$command} {$arguments}");
    $process->setTimeout(3600);
    $process->run();

    if (!$process->isSuccessful()) {
      throw new \RuntimeException($process->getErrorOutput());
    }

    // Some drush commands write to standard error output (for example enable
    // use drush_log which default to _drush_print_log) instead of returning a
    // string (drush status use drush_print_pipe).
    if (!$process->getOutput()) {
      return $process->getErrorOutput();
    }
    else {
      return $process->getOutput();
    }

  }

  /**
   * {@inheritdoc}
   */
  public function processBatch() {
    // Do nothing. Drush should internally handle any needs for processing
    // batch ops.
  }

  /**
   * {@inheritdoc}
   */
  public function runCron() {
    $this->drush('cron');
  }

  /**
   * Run Drush commands dynamically from a DrupalContext.
   */
  public function __call($name, $arguments) {
    return $this->drush($name, $arguments);
  }

}


1			<?php
2
3			namespace Drupal\Driver;
4
5			use Drupal\Component\Utility\Random;
6			use Drupal\Driver\Exception\BootstrapException;
7
8			use Symfony\Component\Process\Process;
9
10			/**
11			* Implements DriverInterface.
12			*/
13			class DrushDriver extends BaseDriver {
14			/**
15			* Store a drush alias for tests requiring shell access.
16			*
17			* @var string
18			*/
19			public $alias;
20
21			/**
22			* Stores the root path to a Drupal installation.
23			*
24			* This is an alternative to using drush aliases.
25			*
26			* @var string
27			*/
28			public $root;
29
30			/**
31			* Store the path to drush binary.
32			*
33			* @var string
34			*/
35			public $binary;
36
37			/**
38			* Track bootstrapping.
39			*
40			* @var bool
41			*/
42			private $bootstrapped = FALSE;
43
44			/**
45			* Random generator.
46			*
47			* @var \Drupal\Component\Utility\Random
48			*/
49			private $random;
50
51			/**
52			* Global arguments or options for drush commands.
53			*
54			* @var string
55			*/
56			private $arguments = '';
57
58			/**
59			* Tracks legacy drush.
60			*
61			* @var bool
62			*/
63			protected static $isLegacyDrush;
64
65			/**
66			* Set drush alias or root path.
67			*
68			* @param string $alias
69			* A drush alias.
70			* @param string $root_path
71			* The root path of the Drupal install. This is an alternative to using
72			* aliases.
73			* @param string $binary
74			* The path to the drush binary.
75			* @param \Drupal\Component\Utility\Random $random
76			* Random generator.
77			*
78			* @throws \Drupal\Driver\Exception\BootstrapException
79			* Thrown when a required parameter is missing.
80			*/
81			public function __construct($alias = NULL, $root_path = NULL, $binary = 'drush', Random $random = NULL) {
82			if (!empty($alias)) {
83			// Trim off the '@' symbol if it has been added.
84			$alias = ltrim($alias, '@');
85
86			$this->alias = $alias;
87			}
88			elseif (!empty($root_path)) {
89			$this->root = realpath($root_path);
90			}
91			else {
92			throw new BootstrapException('A drush alias or root path is required.');
93			}
94
95			$this->binary = $binary;
96
97			if (!isset($random)) {
98			$random = new Random();
99			}
100			$this->random = $random;
101			}
102
103			/**
104			* {@inheritdoc}
105			*/
106			public function getRandom() {
107			return $this->random;
108			}
109
110			/**
111			* {@inheritdoc}
112			*/
113			public function bootstrap() {
114			// Check that the given alias works.
115			// @todo check that this is a functioning alias.
116			// See http://drupal.org/node/1615450
117			if (!isset($this->alias) && !isset($this->root)) {
118			throw new BootstrapException('A drush alias or root path is required.');
119			}
120
121			// Determine if drush version is legacy.
122			if (!isset(self::$isLegacyDrush)) {
123			self::$isLegacyDrush = $this->isLegacyDrush();
124			}
125
126			$this->bootstrapped = TRUE;
127			}
128
129			/**
130			* Determine if drush is a legacy version.
131			*
132			* @return bool
133			* Returns TRUE if drush is older than drush 9.
134			*/
135			protected function isLegacyDrush() {
136			try {
137			// Try for a drush 9 version.
138			$version = trim($this->drush('version', [], ['format' => 'string']));
139			return version_compare($version, '9', '<=');
140			}
141			catch (\RuntimeException $e) {
142			// The version of drush is old enough that only `--version` was available,
143			// so this is a legacy version.
144			return TRUE;
145			}
146			}
147
148			/**
149			* {@inheritdoc}
150			*/
151			public function isBootstrapped() {
152			return $this->bootstrapped;
153			}
154
155			/**
156			* {@inheritdoc}
157			*/
158			public function userCreate(\stdClass $user) {
159			$arguments = array(
160			sprintf('"%s"', $user->name),
161			);
162			$options = array(
163			'password' => $user->pass,
164			'mail' => $user->mail,
165			);
166			$result = $this->drush('user-create', $arguments, $options);
167			if ($uid = $this->parseUserId($result)) {
168			$user->uid = $uid;
169			}
170			if (isset($user->roles) && is_array($user->roles)) {
171			foreach ($user->roles as $role) {
172			$this->userAddRole($user, $role);
173			}
174			}
175			}
176
177			/**
178			* Parse user id from drush user-information output.
179			*/
180			protected function parseUserId($info) {
181			// Find the row containing "User ID : xxx".
182			preg_match('/User ID\s+:\s+\d+/', $info, $matches);
183			if (!empty($matches)) {
184			// Extract the ID from the row.
185			list(, $uid) = explode(':', $matches[0]);
186			return (int) $uid;
187			}
188			}
189
190			/**
191			* {@inheritdoc}
192			*/
193			public function userDelete(\stdClass $user) {
194			$arguments = array(sprintf('"%s"', $user->name));
195			$options = array(
196			'yes' => NULL,
197			'delete-content' => NULL,
198			);
199			$this->drush('user-cancel', $arguments, $options);
200			}
201
202			/**
203			* {@inheritdoc}
204			*/
205			public function userAddRole(\stdClass $user, $role) {
206			$arguments = array(
207			sprintf('"%s"', $role),
208			sprintf('"%s"', $user->name),
209			);
210			$this->drush('user-add-role', $arguments);
211			}
212
213			/**
214			* {@inheritdoc}
215			*/
216			public function fetchWatchdog($count = 10, $type = NULL, $severity = NULL) {
217			$options = array(
218			'count' => $count,
219			'type' => $type,
220			'severity' => $severity,
221			);
222			return $this->drush('watchdog-show', array(), $options);
223			}
224
225			/**
226			* {@inheritdoc}
227			*/
228			public function clearCache($type = 'all') {
229			$type = array($type);
230			return $this->drush('cache-clear', $type, array());
231			}
232
233			/**
234			* {@inheritdoc}
235			*/
236			public function clearStaticCaches() {
237			// The drush driver does each operation as a separate request;
238			// therefore, 'clearStaticCaches' can be a no-op.
239			}
240
241			/**
242			* Decodes JSON object returned by Drush.
243			*
244			* It will clean up any junk that may have appeared before or after the
245			* JSON object. This can happen with remote Drush aliases.
246			*
247			* @param string $output
248			* The output from Drush.
249			*
250			* @return object
251			* The decoded JSON object.
252			*/
253			protected function decodeJsonObject($output) {
254			// Remove anything before the first '{'.
255			$output = preg_replace('/^[^\{]*/', '', $output);
256			// Remove anything after the last '}'.
257			$output = preg_replace('/[^\}]*$/s', '', $output);
258			return json_decode($output);
259			}
260
261			/**
262			* {@inheritdoc}
263			*/
264			public function createNode($node) {
265			// Look up author by name.
266			if (isset($node->author)) {
267			$user_info = $this->drush('user-information', array(sprintf('"%s"', $node->author)));
268			if ($uid = $this->parseUserId($user_info)) {
269			$node->uid = $uid;
270			}
271			}
272			$result = $this->drush('behat', array('create-node', escapeshellarg(json_encode($node))), array());
273			return $this->decodeJsonObject($result);
274			}
275
276			/**
277			* {@inheritdoc}
278			*/
279			public function nodeDelete($node) {
280			$this->drush('behat', array('delete-node', escapeshellarg(json_encode($node))), array());
281			}
282
283			/**
284			* {@inheritdoc}
285			*/
286			public function createTerm(\stdClass $term) {
287			$result = $this->drush('behat', array('create-term', escapeshellarg(json_encode($term))), array());
288			return $this->decodeJsonObject($result);
289			}
290
291			/**
292			* {@inheritdoc}
293			*/
294			public function termDelete(\stdClass $term) {
295			$this->drush('behat', array('delete-term', escapeshellarg(json_encode($term))), array());
296			}
297
298			/**
299			* {@inheritdoc}
300			*/
301			public function isField($entity_type, $field_name) {
302			// If the Behat Drush Endpoint is not installed on the site-under-test,
303			// then the drush() method will throw an exception. In this instance, we
304			// want to treat all potential fields as non-fields. This allows the
305			// Drush Driver to work with certain built-in Drush capabilities (e.g.
306			// creating users) even if the Behat Drush Endpoint is not available.
307			try {
308			$value = array($entity_type, $field_name);
309			$arguments = array('is-field', escapeshellarg(json_encode($value)));
310			$result = $this->drush('behat', $arguments, array());
311			return strpos($result, "true\n") !== FALSE;
312			}
313			catch (\Exception $e) {
314			return FALSE;
315			}
316			}
317
318			/**
319			* Sets common drush arguments or options.
320			*
321			* @param string $arguments
322			* Global arguments to add to every drush command.
323			*/
324			public function setArguments($arguments) {
325			$this->arguments = $arguments;
326			}
327
328			/**
329			* Get common drush arguments.
330			*/
331			public function getArguments() {
332			return $this->arguments;
333			}
334
335			/**
336			* Parse arguments into a string.
337			*
338			* @param array $arguments
339			* An array of argument/option names to values.
340			*
341			* @return string
342			* The parsed arguments.
343			*/
344			protected static function parseArguments(array $arguments) {
345			$string = '';
346			foreach ($arguments as $name => $value) {
347			if (is_null($value)) {
348			$string .= ' --' . $name;
349			}
350			else {
351			$string .= ' --' . $name . '=' . $value;
352			}
353			}
354			return $string;
355			}
356
357			/**
358			* Execute a drush command.
359			*/
360			public function drush($command, array $arguments = array(), array $options = array()) {
361			$arguments = implode(' ', $arguments);
362
363			// Disable colored output from drush.
364			if (isset(static::$isLegacyDrush) && static::$isLegacyDrush) {
365			$options['nocolor'] = TRUE;
366			}
367			else {
368			$options['no-ansi'] = NULL;
369			}
370			$string_options = $this->parseArguments($options);
371
372			$alias = isset($this->alias) ? "@{$this->alias}" : '--root=' . $this->root;
373
374			// Add any global arguments.
375			$global = $this->getArguments();
376
377			$process = new Process("{$this->binary} {$alias} {$string_options} {$global} {$command} {$arguments}");
378			$process->setTimeout(3600);
379			$process->run();
380
381			if (!$process->isSuccessful()) {
382			throw new \RuntimeException($process->getErrorOutput());
383			}
384
385			// Some drush commands write to standard error output (for example enable
386			// use drush_log which default to _drush_print_log) instead of returning a
387			// string (drush status use drush_print_pipe).
388			if (!$process->getOutput()) {
389			return $process->getErrorOutput();
390			}
391			else {
392			return $process->getOutput();
393			}
394
395			}
396
397			/**
398			* {@inheritdoc}
399			*/
400			public function processBatch() {
401			// Do nothing. Drush should internally handle any needs for processing
402			// batch ops.
403			}
404
405			/**
406			* {@inheritdoc}
407			*/
408			public function runCron() {
409			$this->drush('cron');
410			}
411
412			/**
413			* Run Drush commands dynamically from a DrupalContext.
414			*/
415			public function __call($name, $arguments) {
416			return $this->drush($name, $arguments);
417			}
418
419			}
420

jhedstrom / DrupalDriver

Push — master ( acf9c1...2febee )

DrushDriver::userCreate() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like