MeadSteve\DiceApi\Dice\DiceGenerator

Complexity

Total Complexity

18

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	2
Bugs	0	Features	2

8 Methods

Rating	Name	Duplication	Size	Complexity
A	diceFromUrlString()	0	7	1
A	getDiceForPart()	0	17	3
A	newDiceOfSize()	0	7	2
A	flattenDiceSets()	0	8	2
A	parseDiceString()	0	12	3
A	notBlank()	0	4	1
A	buildBasicNumericDice()	0	11	4
A	buildSteveDice()	0	8	2

<?php

namespace MeadSteve\DiceApi\Dice;

use MeadSteve\DiceApi\BasicDice;
use MeadSteve\DiceApi\Dice;

class DiceGenerator
{
    public function diceFromUrlString($urlString)
    {
        $parts = explode("/", $urlString);
        $parts = array_filter($parts, [$this, 'notBlank']);
        $diceSets = array_map([$this, 'getDiceForPart'], $parts);
        return $this->flattenDiceSets($diceSets);
    }

    /**
     * @param string $part
     * @return Dice[]
     */
    private function getDiceForPart($part)
    {
        $data = $this->parseDiceString($part);
        $type = $data["type"];
        $diceCount = $data["count"];

        if (is_numeric($type)) {
            return $this->buildBasicNumericDice($type, $diceCount);
        }

        switch (strtolower($type)) {
            case "steve":
                return $this->buildSteveDice($type, $diceCount);
        }

        throw new UncreatableDiceException("No idea how to make a d{$type}");
    }

    /**
     * @param $size
     * @return Dice
     */
    private function newDiceOfSize($size)
    {
        if ($size == 0) {
            return new ZeropointDice();
        }
        return new BasicDice($size);
    }

    /**
     * @param array[]
     * @return array
     */
    private function flattenDiceSets($diceSets)
    {
        $dice = [];
        foreach ($diceSets as $set) {
            $dice = array_merge($dice, $set);
        }
        return $dice;
    }

    /**
     * @param string $part
     * @return array
     */
    private function parseDiceString($part)
    {
        $data = [];
        $valid = preg_match("/(?P<count>[0-9]+)?d(?P<type>[^\/]+)/i", $part, $data);
        if (!$valid) {
            throw new UncreatableDiceException("Problem creating dice from incorrectly formated data: " + $part);
        }
        if (!$data["count"]) {
            $data["count"] = 1;
        }
        return $data;
    }

    private function notBlank($string)
    {
        return $string !== "";
    }

    private function buildBasicNumericDice($size, $diceCount) : array
    {
        $newDice = [];
        if ((strlen($size) > 4) || ($size > 9000)) {
            throw new UncreatableDiceException("Only dice with a power level less than 9000 can be created.");
        }
        for ($i = 0; $i < $diceCount; $i++) {
            $newDice[] = $this->newDiceOfSize($size);
        }
        return $newDice;
    }

    private function buildSteveDice($_type, $diceCount)

The parameter $_type is not used and could be removed.

    {
        $newDice = [];
        for ($i = 0; $i < $diceCount; $i++) {
            $newDice[] = new SteveDice();
        }
        return $newDice;
    }
}