ValueCaster::fromJson() - Code Metrics - bytic/data-objects - Measure and Improve Code Quality continuously with Scrutinizer

ValueCaster::fromJson() A
last analyzed 2022-10-11 20:23 UTC

↳ Parent: ValueCaster

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	1
c	0
b	0
f	0
nc	1
nop	2
dl	0
loc	3
rs	10
ccs	0
cts	0
cp	0
crap	2

<?php

namespace ByTIC\DataObjects;

use Carbon\Carbon;
use Carbon\CarbonInterface;
use DateTime;
use DateTimeInterface;

/**
 * Class ValueCaster
 * @package ByTIC\DataObjects
 */
class ValueCaster
{
    /**
     * The built-in, primitive cast types
     *
     * @var array
     */
    public static $primitiveTypes = [
        'array',
        'bool',
        'boolean',
        'collection',
        'custom_datetime',
        'date',
        'datetime',
        'decimal',
        'double',
        'float',
        'int',
        'integer',
        'json',
        'object',
        'real',
        'string',
        'timestamp',
    ];

    public static function as($value, string $type)
    {
        switch ($type) {
            case 'int':
            case 'integer':
                return (int)$value;

            case 'real':
            case 'float':
            case 'double':
                return static::asFloat($value);

            case 'decimal':
                return static::asDecimal($value);

            case 'string':
            case 'str':
                return static::asString($value);

            case 'bool':
            case 'boolean':
                return (bool) $value;

            case 'date':
                return static::asDate($value);

            case 'datetime':
            case 'custom_datetime':
                return static::asDateTime($value);

            case 'timestamp':
                return static::asTimestamp($value);
                return static::/** @scrutinizer ignore-call */ asTimestamp($value);


            case 'object':
                return static::fromJson($value, true);

            case 'array':
            case 'json':
                return static::fromJson($value);
        }
    }

    /**
     * Cast given value to a string
     *
     * @param mixed $value
     *
     * @return string
     */
    public static function asString($value): string
    {
        return (string)$value;
    }

    /**
     * Cast given value to a string
     *
     * @param mixed $value
     *
     * @return string
     */
    public static function asInteger($value): string
    {
        return (int)$value;
    }

    /**
     * Decode the given float.
     *
     * @param  mixed  $value
     * @return mixed
     */
    public static function asFloat($value)
    {
        switch ((string) $value) {
            case 'Infinity':
                return INF;
            case '-Infinity':
                return -INF;
            case 'NaN':
                return NAN;
            default:
                return (float) $value;
        }
    }

    /**
     * Return a decimal as string.
     *
     * @param  float  $value
     * @param  int  $decimals
     * @return string
     */
    public static function asDecimal($value, $decimals = 3)
    {
        return number_format($value, $decimals, '.', '');
    }

    /**
     * Cast given value to a DateTime instance
     *
     * @param string|null $value
     *
     * @return Carbon|DateTimeInterface
     */
    public static function asDate($value)
    {
        $date = static::asDateTime($value);
        if ($date === null) {
            return null;
        }
        return $date->startOfDay();
    }

    /**
     * @param $value
     * @return ?DateTime
     */
    public static function asDateTime($value): ?DateTime
    {
        if (empty($value)) {
            return null;
        }
        // If this value is already a Carbon instance, we shall just return it as is.
        // This prevents us having to re-instantiate a Carbon instance when we know
        // it already is one, which wouldn't be fulfilled by the DateTime check.
        if ($value instanceof CarbonInterface) {
            return Carbon::instance($value);
        }

        // If the value is already a DateTime instance, we will just skip the rest of
        // these checks since they will be a waste of time, and hinder performance
        // when checking the field. We will just return the DateTime right away.
        if ($value instanceof DateTimeInterface) {
            return Carbon::parse(
                $value->format('Y-m-d H:i:s.u'),
                $value->getTimezone()
            );
        }

        // If this value is an integer, we will assume it is a UNIX timestamp's value
        // and format a Carbon object from this timestamp. This allows flexibility
        // when defining your date fields as they might be UNIX timestamps here.
        if (is_numeric($value)) {
            return Carbon::createFromTimestamp($value);
        }

        $date = Carbon::parse($value);
        if ($date->year < 1) {
            return null;
        }

        return $date;
    }

    /**
     * Decode the given JSON back into an array or object.
     *
     * @param string $value
     * @param bool $asObject
     * @return mixed
     */
    public static function fromJson($value, $asObject = false)
    {
        return json_decode($value, !$asObject);
    }

    /**
     * @param $value
     * @return false|string
     */
    public static function asJson($value)
    {
        return json_encode($value);
    }
}


bytic / data-objects

ValueCaster::fromJson() A last analyzed 2022-10-11 20:23 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ValueCaster::fromJson() A
last analyzed 2022-10-11 20:23 UTC