drupol\phpermutations\Permutations

Complexity

Total Complexity

28

Size/Duplication

Total Lines	176
Duplicated Lines	0 %

Coupling/Cohesion

Dependencies

0

Test Coverage

Coverage

83.72%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
A	setSize()	0	3	1
A	getSize()	0	3	1
A	setElements()	0	5	1
A	getElements()	0	3	1
A	generator()	0	3	1
C	generate()	0	24	7
C	product()	0	33	8
A	toIter()	0	12	4
A	toArray()	0	9	2

<?php

namespace drupol\phpermutations;

/**
 * Class Permutations.
 *
 * @package drupol\phpermutations
 */
class Permutations {

  /**
   * @var mixed
   */
  protected $elements;

  /**
   * @var int
   */
  protected $size;

  /**
   * Permutations constructor.
   *
   * @param array $elements
   * @param int $size

Should the type for parameter $size not be integer|null?

   */
  public function __construct(array $elements, $size = NULL) {

TRUE, FALSE and NULL must be lowercase; expected null, but found NULL.

    $this->setElements($elements);
    $size = $size ? $size : count($elements);

Consider using a different name than the parameter $size. This often makes code more readable.

    $this->setSize($size);

    return $this;

Constructors do not have meaningful return values, anything that is returned from here is discarded. Are you sure this is correct?

  }

  /**
   * @param int $size
   */
  public function setSize($size) {
    $this->size = $size;
  }

  /**
   * @return int
   */
  public function getSize() {
    return (int) $this->size;
  }

  /**
   * @param array $elements
   *
   * @return $this
   */
  public function setElements(array $elements) {
    $this->elements = $elements;

    return $this;
  }

  /**
   * @return mixed
   */
  public function getElements() {
    return $this->elements;
  }

  /**
   * @return \Generator
   */
  public function generator() {
    return $this->generate($this->getElements(), $this->getSize());
  }

  /**
   * @param array $elements
   * @param $subset_length
   *
   * @return \Generator
   */
  protected function generate(array $elements, $subset_length) {

The parameter $subset_length is not named in camelCase.

The variable $subset_length is not named in camelCase.

    $length = \count($elements);
    if($subset_length === null){

Expected 1 space after IF keyword; 0 found

      $subset_length = $length;

Consider using a different name than the parameter $subset_length. This often makes code more readable.

    }
    if($subset_length > $length){

Expected 1 space after IF keyword; 0 found

      $subset_length = $length;

Consider using a different name than the parameter $subset_length. This often makes code more readable.

    }
    $pools = [];
    for ($i = 0; $i < $subset_length; $i++) {
      $pools[] = $elements;
    }
    $productGenerator = $this->product($pools);
    foreach($productGenerator as $key => $indices){

Expected 1 space after FOREACH keyword; 0 found

      $flipIndices = array_keys(array_flip($indices));
      if(\count($flipIndices) == $subset_length){

Expected 1 space after IF keyword; 0 found

        $permute = [];
        foreach($indices as $k => $i){

Expected 1 space after FOREACH keyword; 0 found

          $permute[] = $elements[$key[$k]];
        }
        yield $key => $permute;
      }
    }
  }

  /**
   * Returns the cartesian product of iterables that were passed as arguments.
   *
   * The resulting iterator will contain all the possible tuples of keys and
   * values.
   *
   * @param array|Traversable $iterables
   *   Iterables to combine
   *
   * @return \Iterator

Consider making the return type a bit more specific; maybe use \Generator.

   */
  function product($iterables) {

It is generally recommended to explicitly declare the visibility for methods.

It is recommend to declare an explicit visibility for product.

    /** @var \Iterator[] $iterators */
    $iterators = array_map(array($this, 'toIter'), $iterables);
    $numIterators = count($iterators);
    if (!$numIterators) {
      yield [] => [];
      return;
    }
    $keyTuple = $valueTuple = array_fill(0, $numIterators, null);
    $i = -1;
    while (true) {
      while (++$i < $numIterators - 1) {
        $iterators[$i]->rewind();
        if (!$iterators[$i]->valid()) {
          return;
        }
        $keyTuple[$i] = $iterators[$i]->key();
        $valueTuple[$i] = $iterators[$i]->current();
      }
      foreach ($iterators[$i] as $keyTuple[$i] => $valueTuple[$i]) {
        yield $keyTuple => $valueTuple;
      }
      while (--$i >= 0) {
        $iterators[$i]->next();
        if ($iterators[$i]->valid()) {
          $keyTuple[$i] = $iterators[$i]->key();
          $valueTuple[$i] = $iterators[$i]->current();
          continue 2;
        }
      }
      return;
    }
  }

  /**
   * Converts any iterable into an Iterator.
   *
   * @param array|Traversable $iterable
   *   The iterable to turn into an iterator.
   *
   * @return \Iterator
   */
  function toIter($iterable) {

It is generally recommended to explicitly declare the visibility for methods.

It is recommend to declare an explicit visibility for toIter.

    if ($iterable instanceof \Iterator) {
      return $iterable;
    }
    if ($iterable instanceof \IteratorAggregate) {
      return $iterable->getIterator();
    }
    if (is_array($iterable)) {
      return new \ArrayIterator($iterable);
    }
    throw new \InvalidArgumentException('Argument must be iterable');
  }

  /**
   * @return array
   */
  public function toArray() {
    $results = array();

    foreach($this->generator() as $value) {

Expected 1 space after FOREACH keyword; 0 found

      $results[] = $value;
    }

    return $results;
  }

}