Get the step index format of the step precision

@return array
343213
public function getStepFormat()
    {
        if ($this->lang == 'en') {
            switch ($this->step) {
                case self::$YEARLY:
                    return 'Y';
                    break;
                case self::$MONTHLY:
                    return 'Y-m';
                    break;
                case self::$DAILY:
                    return 'Y-m-d';
                    break;
                case self::$HOURLY:
                    return 'Y-m-d H:00';
                    break;
            }
        } elseif ($this->lang == 'fr') {
            switch ($this->step) {
                case self::$YEARLY:
                    return 'Y';
                    break;
                case self::$MONTHLY:
                    return 'm/Y';
                    break;
                case self::$DAILY:
                    return 'd/m/Y';
                    break;
                case self::$HOURLY:
                    return 'd/m/Y H:00';
                    break;
            }
        }

        return false;
    }
1181073
public function getAllTimeFormatFlat()
    {
        $aOut     = [];
        $aFormats = $this->getAllTimeFormat();

        foreach ($aFormats as $oFormat) {
            $aOut[$oFormat->slug] = $oFormat->label;
        }

        return $aOut;
    }
32689
public function monochromatic(int $steps = 5): array
    {
        $colors          = [];
        $percentage      = 80 / $steps;
        $numberToLighten = floor(($this->baseColor->getHsl()['l'] * 80) / $percentage);

        for ($i = $numberToLighten; $i > 0; $i--) {
            array_push($colors, $this->baseColor->lighten($percentage * $i));
        }

        array_push($colors, $this->baseColor);

        for ($i = 1; $i < $steps - $numberToLighten + 1; $i++) {
            array_push($colors, $this->baseColor->darken($percentage * $i));
        }

        return $colors;
    }
1070538
public static function getFormats() : array
    {
        return [
            self::FORMAT_GSM => self::FORMAT_GSM,
            self::FORMAT_UNICODE => self::FORMAT_UNICODE,
            self::FORMAT_BINARY => self::FORMAT_BINARY,
            self::FORMAT_WAPPUSH => self::FORMAT_WAPPUSH,
            self::FORMAT_MMS => self::FORMAT_MMS
        ];
    }
1038012
public function getStepIndexes()
    {
        $dates = [];

        // TODO : Think about doing this a cleaner way with carbon instead with timestamps ...
        $current = $this->start->timestamp;
        $last = $this->end->timestamp;

        while ($current <= $last) {
            $dates[] = date($this->getStepFormat(), $current);
            $current = strtotime($this->getStepIncrement(), $current);
        }

        return $dates;
    }
1305459
public function getSizes()
    {
        $sizes = [];
        if ($this->phoneSize === 'auto') {
            $sizes['phone'] = $this->generatePhoneSize();
        } elseif ($this->phoneSize === true && $this->hasPhoneColumns) {
            $sizes['phone'] = $this->phoneColumns;
        }
        if ($this->tabletSize === 'auto') {
            $sizes['tablet'] = $this->generateTabletSize();
        } elseif ($this->tabletSize === true && $this->hasTabletColumns) {
            $sizes['tablet'] = $this->tabletColumns;
        }
        if ($this->mediumDesktopSize === 'auto') {
            $sizes['mediumDesktop'] = $this->generateMediumDesktopSize();
        } elseif ($this->mediumDesktopSize === true && $this->hasMediumDesktopColumns) {
            $sizes['mediumDesktop'] = $this->mediumDesktopColumns;
        }
        if ($this->largeDesktopSize === 'auto') {
            $sizes['largeDesktop'] = $this->generateLargeDesktopSize();
        } elseif ($this->largeDesktopSize === true && $this->hasLargeDesktopColumns) {
            $sizes['largeDesktop'] = $this->largeDesktopColumns;
        }

        return $sizes;
    }
1280552
public function getMeta()
    {
        $result = [
            'latitude' => $this->latitude,
            'longitude' => $this->longitude,
            'timezone' => ($this->date->getTimezone())->getName(),
            'method' => $this->methods[$this->method],
            'latitudeAdjustmentMethod' => $this->latitudeAdjustmentMethod,
            'midnightMode' => $this->midnightMode,
            'school' => $this->school,
            'offset' => $this->offset,
        ];
        if (isset($result['method']['offset'])) {
            unset($result['method']['offset']);
        }

        return $result;
    }
1187471
protected function processSteps()
    {
        return [
            Steps\CheckConditionsAndSetup::class,

            Steps\StubReplaceSimple::class,
            Steps\StubReplaceAttributeData::class,
            Steps\StubReplaceRelationData::class,
            Steps\StubReplaceAccessorsAndMutators::class,
            Steps\StubReplaceSluggableData::class,
            Steps\StubReplaceScopes::class,
            Steps\StubReplaceDocBlock::class,
            Steps\StubReplaceImportsAndTraits::class,

            Steps\WriteFile::class,
        ];
    }
228654
protected function scanStep()
    {
        if (!$this->allowSteps) {
            return null;
        }

        $keywords = $this->getKeywords('Step');
        if (!preg_match('/^\s*(' . $keywords . ')([^\s].+)/u', $this->line, $matches)) {
            return null;
        }

        $keyword = trim($matches[1]);
        $token = $this->takeToken('Step', $keyword);
        $token['keyword_type'] = $this->getStepKeywordType($keyword);
        $token['text'] = $matches[2];

        $this->consumeLine();
        $this->allowMultilineArguments = true;

        return $token;
    }
1329956
public function booleanFormat()
    {
        return [
            self::BOOL_Y => Yii::t('yii', 'Yes', [], \Yii::$app->formatter->locale),
            self::BOOL_N => Yii::t('yii', 'No', [], \Yii::$app->formatter->locale),
        ];
    }
1252843
protected function getIndexes()
    {
        $indexes = [];
        $rawIndexes = $this->getRawIndexes();

        foreach ($rawIndexes as $rawIndex) {
            $index = new Index($rawIndex->name);
            $index->addColumns(explode('|||', $rawIndex->columns));

            $indexes[] = $index;
        }

        return $indexes;
    }
680027
protected function getDimensionsForUnixLike(): ?array
	{
		// Attempt to get dimensions from environment

		if(($width = getenv('COLUMNS')) !== false && ($height = getenv('LINES')) !== false)
		{
			return ['width' => (int) $width, 'height' => (int) $height];
		}

		// Attempt to get dimensions from stty

		exec('stty size', $output, $status);

		if($status === 0 && preg_match('/^([0-9]+) ([0-9]+)$/', current($output), $matches))
		{
			return ['width' => (int) $matches[2], 'height' => (int) $matches[1]];
		}

		// All attempts failed so we'll just return null

		return null;
	}
1090020
private function getStepsSortedDescByPriority()
    {
        $steps = $this->steps;
        // Use illogically large and small priorities
        $steps[-255][] = new Step\ArrayCheckStep;
        foreach ($this->writers as $writer) {
            $steps[-256][] = new Step\WriterStep($writer);
        }

        krsort($steps);

        $sortedStep = [];
        /** @var Step[] $stepsAtSamePriority */
        foreach ($steps as $stepsAtSamePriority) {
            foreach ($stepsAtSamePriority as $step) {
                $sortedStep[] = $step;
            }
        }

        return array_reverse($sortedStep);
    }
710002
public function getAllDateFormatFlat()
    {
        $aOut     = [];
        $aFormats = $this->getAllDateFormat();

        foreach ($aFormats as $oFormat) {
            $aOut[$oFormat->slug] = $oFormat->example;
        }

        return $aOut;
    }
859497
public function getStepsArray()
    {
        $steps = null;

        if ($this->getSteps() && $this->getSteps()[0] === '{') {
            $steps = json_decode($this->getSteps(), true);
        } elseif ($this->getSteps()) {
            $steps = explode(',', $this->getSteps());
        }
        if (!$steps) {
            $steps = array('index','play','result','bounce');
        }
        return $steps;
    }
759933
public function getStepAttribute()
    {
        if ($this->attributes['data'] == '' || $this->attributes['type'] != 'number')
            return null;

        $data = unserialize($this->attributes['data']);

        if (!isset($data['step']))
            return null;
        else {
            return $data['step'];
        }
    }
1113129
public function format(array $steps)
    {
        return implode(
            array_map(
                function (StepNode $step) {
                    return $this->getStepText($step) . $this->getArguments($step);
                },
                $steps
            )
        );
    }