private function permutation($array) {
      switch (count($array)) {
        case 0:
        case 1:
          return array($array);
      }

      foreach ($array as $k => $v) {
        $copy = $array;
        unset($copy[$k]);

        foreach ($this->permutation($copy) as $other) {
          $other[] = $v;
          $return[] = $other;
        }
      }

      return $return;
    }

    /**
     * Finds alternative of $name among $collection,
     * if nothing is found in $collection, try in $abbrevs.
     *
     * @param string             $name       The string
     * @param array|\Traversable $collection The collection
     *
     * @return array A sorted array of similar string
     */
    private function findAlternatives($name, $collection)
    {
        $alternatives = array();

        $nameParts = explode(':', $name);
        $namePartsCount = count($nameParts);

        foreach ($collection as $item) {
            // Saving the collectionParts by item, we might need them later
            $collectionParts[$item] = explode(':', $item);

            $notFoundCount = count(array_diff($nameParts, $collectionParts[$item]));

            if ($notFoundCount < $namePartsCount) {
              $alternatives[] = $item;
            }
        }

        if (count($alternatives) !== 0) {
          sort($alternatives);
          return $alternatives;
        }

        foreach ($collectionParts as $fullName => $parts) {
          $score = PHP_INT_MAX;

          // Find all different orders of how to match collectionName to name
          // use the best match
          foreach ($this->permutation($parts) as $i => $parts2) {
            // We can only match one part onto one subname
            $parts2 = array_slice($parts2, 0, $namePartsCount);

            $scoreAllParts = 0;
            foreach ($parts2 as $i2 => $part2) {
              // We suppose it's more likely that the user gets the command
              // wrong the longer it is. So we compensate by the name length.
              $scoreAllParts += levenshtein($nameParts[$i2], $part2) / count($nameParts[$i2]);
            }

            if ($scoreAllParts < $score) {
              $score = $scoreAllParts;
            }
          }

          $alternatives[$fullName] = $score;
        }

        // Don't return result which are too unlikely to match
        $alternatives = array_filter($alternatives, function($el) {
          return $el <= 3;
        });

        // Sort by levenshtein first, then alfabetically
        array_multisort($alternatives, array_values($alternatives), SORT_ASC, array_keys($alternatives), SORT_ASC);

        return array_keys($alternatives);
    }