Carbonated::carbonatedAccessor() - Code Metrics - Inspection of "Add Localization" - okaufmann/Carbonated - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1)

by Oliver

created 2017-04-24 20:53 UTC

Carbonated::carbonatedAccessor() B

↳ Parent: Carbonated

Complexity

Conditions	5
Paths	8

Size

Total Lines	23
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	23
rs	8.5906
c	0
b	0
f	0
cc	5
eloc	10
nc	8
nop	2

<?php

namespace ThisVessel;

use Carbon\Carbon;
use Request;

trait Carbonated
{
    /**
     * Store carbon instances for reuse.
     *
     * @var object
     */
    protected $carbonInstances;

    /**
     * Indicate whether accessors should be overridden to return carbon instances.
     *
     * @var bool
     */
    protected $returnCarbon = false;

    /**
     * Get the attributes that should be handled as carbonated timestamps.
     *
     * @return array
     */
    public function carbonatedTimestamps()
    {
        // Add default fields for schema builder's timestamps() and softDeletes().
        $defaults = [static::CREATED_AT, static::UPDATED_AT, 'deleted_at'];

        return $this->ensureProperty($this, 'carbonatedTimestamps') ? array_unique(array_merge($this->carbonatedTimestamps, $defaults)) : $defaults;
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Get the attributes that should be handled as carbonated dates.
     *
     * @return array
     */
    public function carbonatedDates()
    {
        return $this->ensureProperty($this, 'carbonatedDates') ? (array) $this->carbonatedDates : [];
    }

    /**
     * Get the attributes that should be handled as carbonated times.
     *
     * @return array
     */
    public function carbonatedTimes()
    {
        return $this->ensureProperty($this, 'carbonatedTimes') ? (array) $this->carbonatedTimes : [];
    }

    /**
     * Get all attributes that should be handled by carbonated.
     *
     * @return array
     */
    public function carbonatedAttributes()
    {
        return array_merge($this->carbonatedTimestamps(), $this->carbonatedDates(), $this->carbonatedTimes());
    }

    /**
     * Get carbonated attribute type.
     *
     * @param string $key
     *
     * @return string
     */
    public function carbonatedAttributeType($key)
    {
        if (in_array($key, $this->carbonatedTimestamps())) {
            return 'timestamp';
        } elseif (in_array($key, $this->carbonatedDates())) {
            return 'date';
        } elseif (in_array($key, $this->carbonatedTimes())) {
            return 'time';
        }

        return false;
    }

    /**
     * Get the intended timestamp format for view output.
     *
     * @return string
     */
    public function carbonatedTimestampFormat()
    {
        return $this->ensureProperty($this, 'carbonatedTimestampFormat') ? (string) $this->carbonatedTimestampFormat : 'M d, Y g:ia';
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Get the intended date format for view output.
     *
     * @return string
     */
    public function carbonatedDateFormat()
    {
        return $this->ensureProperty($this, 'carbonatedDateFormat') ? (string) $this->carbonatedDateFormat : 'M d, Y';
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Get the intended date format for view output.
     *
     * @return string
     */
    public function carbonatedTimeFormat()
    {
        return $this->ensureProperty($this, 'carbonatedTimeFormat') ? (string) $this->carbonatedTimeFormat : 'g:ia';
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Get the intended timezone for view output.
     *
     * @return string
     */
    public function carbonatedTimezone()
    {
        // Check for $carbonatedTimezone property in model.
        if ($this->ensureProperty($this, 'carbonatedTimezone')) {
            return (string) $this->carbonatedTimezone;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        } // If not, check for an authenticated user with a $timezone property.
        elseif (class_exists(\Auth::class) && \Auth::check() && \Auth::user()->timezone) {
            return (string) \Auth::user()->timezone;
        }

        // Otherwise use same timezone as database.
        return $this->databaseTimezone();
    }

    /**
     * Get the intended timestamp for json output.
     *
     * @return string
     */
    public function jsonTimestampFormat()
    {
        return $this->ensureProperty($this, 'jsonTimestampFormat') ? (string) $this->jsonTimestampFormat : $this->databaseTimestampFormat();
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Get the intended date for json output.
     *
     * @return string
     */
    public function jsonDateFormat()
    {
        return $this->ensureProperty($this, 'jsonDateFormat') ? (string) $this->jsonDateFormat : $this->databaseDateFormat();
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Get the intended time for json output.
     *
     * @return string
     */
    public function jsonTimeFormat()
    {
        return $this->ensureProperty($this, 'jsonTimeFormat') ? (string) $this->jsonTimeFormat : $this->databaseTimeFormat();
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Get the intended timezone for json output.
     *
     * @return string
     */
    public function jsonTimezone()
    {
        // Check for $jsonTimezone property in model.
        if ($this->ensureProperty($this, 'jsonTimezone')) {
            return (string) $this->jsonTimezone;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        }

        // Otherwise use same timezone as database.
        return $this->databaseTimezone();
    }

    /**
     * Get the intended database format for timestamp storage.
     *
     * @return string
     */
    public function databaseTimestampFormat()
    {
        return $this->ensureProperty($this, 'databaseTimestampFormat') ? (string) $this->databaseTimestampFormat : 'Y-m-d H:i:s';
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Get the intended database format for date storage.
     *
     * @return string
     */
    public function databaseDateFormat()
    {
        return $this->ensureProperty($this, 'databaseDateFormat') ? (string) $this->databaseDateFormat : 'Y-m-d';
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Get the intended database format for time storage.
     *
     * @return string
     */
    public function databaseTimeFormat()
    {
        return $this->ensureProperty($this, 'databaseTimeFormat') ? (string) $this->databaseTimeFormat : 'H:i:s';
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Get the intended timezone for database storage.
     *
     * @return string
     */
    public function databaseTimezone()
    {
        // Check for $databaseTimezone property in model.
        if ($this->ensureProperty($this, 'databaseTimezone')) {
            return (string) $this->databaseTimezone;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        }

        // Otherwise use app's timezone configuration.
        return (string) function_exists('config') ? config('app.timezone') : 'UTC';
    }

    /**
     * Store and return carbon instances for reuse.
     *
     * @return object
     */
    protected function carbonInstances()
    {
        // Check if date/time fields have already been carbonated.
        if ($this->carbonInstances) {
            return $this->carbonInstances;
        }

        // If not, get timezones.
        $databaseTimezone = $this->databaseTimezone();
        $carbonatedTimezone = $this->carbonatedTimezone();

        // Get database field formats.
        foreach ($this->carbonatedTimestamps() as $field) {
            $fieldFormats[$field] = $this->databaseTimestampFormat();
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
        }
        foreach ($this->carbonatedDates() as $field) {
            $fieldFormats[$field] = $this->databaseDateFormat();
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
        }
        foreach ($this->carbonatedTimes() as $field) {
            $fieldFormats[$field] = $this->databaseTimeFormat();
        }

        // Create Carbon instances.
        foreach ($fieldFormats as $field => $format) {
            $value = isset($this->attributes[$field]) ? $this->attributes[$field] : null;
class MyClass { }

$x = new MyClass();
$x->foo = true;
            $carbonInstance = $value ? Carbon::createFromFormat($format, $value, $databaseTimezone) : null;
            $carbonInstances[$field] = $carbonInstance ? $carbonInstance->timezone($carbonatedTimezone) : null;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
        }

        // Store Carbon instances for future use.
        $this->carbonInstances = isset($carbonInstances) ? (object) $carbonInstances : null;

        // Return Carbon instances.
        return $this->carbonInstances;
    }

    /**
     * Return a clone of $this object and modify it's accessors.
     *
     * @return $this
     */
    public function getWithCarbonAttribute()
    {
        // Clone $this to preserve it's state.
        $clone = clone $this;

        // Modify clone's accessors.
        $clone->returnCarbon = true;

        // Return clone.
        return $clone;
    }

    /**
     * Access and format for front end.
     *
     * @param string $key
     * @param bool   $json
     *
     * @return string
     */
    public function carbonatedAccessor($key, $json = false)
    {
        // Initial accesor setup.
        $accessorType = $json ? 'json' : 'carbonated';
        $fieldType = $this->carbonatedAttributeType($key);

        // Get output format and timezone for conversion.
        $outputFormat = $this->{$accessorType.ucfirst($fieldType).'Format'}();
        $outputTimezone = $this->{$accessorType.'Timezone'}();

        // Get Carbon instance.
        /** @var Carbon $carbonInstance */
        $carbonInstance = $this->carbonInstances()->$key;

        // Return formatted value.
        $timezonedInstance = $carbonInstance->timezone($outputTimezone);

        if ($this->useLocalizedFormats()) {
            return $carbonInstance ? $timezonedInstance->formatLocalized($outputFormat) : null;
        }

        return $carbonInstance ? $timezonedInstance->format($outputFormat) : null;
    }

    /**
     * Mutate to a storable value for database.
     *
     * @param string $key
     * @param mixed  $value
     *
     * @return string
     */
    public function carbonatedMutator($key, $value)
    {
        // Get type.
        $fieldType = $this->carbonatedAttributeType($key);

        // Get database format and timezone.
        $databaseFormat = $this->{'database'.ucfirst($fieldType).'Format'}();
        $databaseTimezone = $this->databaseTimezone();

        // If value is DateTime instance, convert to Carbon instance.
        if ($value instanceof \DateTime) {
            $value = Carbon::instance($value);
        }

        // It value is Carbon intance, return storable value.
        if ($value instanceof Carbon) {
            return $value->timezone($databaseTimezone)->format($databaseFormat);
        }

        // Otherwise, get input format and timezone for conversion.
        if (static::requestIsJson()) {
            $inputFormat = $this->{'json'.ucfirst($fieldType).'Format'}();
            $inputTimezone = $this->jsonTimezone();
        } else {
            $inputFormat = $this->{'carbonated'.ucfirst($fieldType).'Format'}();
            $inputTimezone = $this->carbonatedTimezone();
        }

        // Convert to Carbon instance.
        $carbonInstance = $value ? Carbon::createFromFormat($inputFormat, $value, $inputTimezone) : null;

        // Return storable value.
        return $carbonInstance ? $carbonInstance->timezone($databaseTimezone)->format($databaseFormat) : null;
    }

    /**
     * Check if request is some type of JSON (purposefully more lenient than current Request::isJson() helper).
     *
     * @return bool
     */
    public static function requestIsJson()
    {
        return str_contains(Request::header('CONTENT_TYPE'), 'json');

    }

    /**
     * Override default getDates() to allow created_at and updated_at handling by carbonated.
     *
     * @return array
     */
    public function getDates()
    {
        return (array) $this->dates;
    }

    /**
     * Override default freshTimestamp() to be more explicit in setting timezone for storage.
     *
     * @return \Carbon\Carbon
     */
    public function freshTimestamp()
    {
        $databaseTimezone = $this->databaseTimezone();

        return Carbon::now($databaseTimezone);
    }

    /**
     * Override default toArray() to include our own accessors.
     *
     * @param bool $useJsonAccessors
     *
     * @return array
     */
    public function toArray($useJsonAccessors = false)
    {
        $attributes = $this->attributesToArray();


        // If returning JSON output, reference our own accessors for relevant date/time fields.
        if ($useJsonAccessors) {
            foreach ($attributes as $key => $value) {
                if (!$this->hasGetMutator($key) && in_array($key, $this->carbonatedAttributes())) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                    $attributes[$key] = $this->carbonatedAccessor($key, true);
                }
            }
        }

        return array_merge($attributes, $this->relationsToArray());

    }

    /**
     * Override default jsonSerialize() to set $useJsonAccessors parameter.
     *
     * @return array
     */
    public function jsonSerialize()
    {
        return $this->toArray(true);
    }

    /**
     * Override default getAttributeValue() to include our own accessors.
     *
     * @param string $key
     *
     * @return mixed
     */
    public function getAttributeValue($key)
    {
        $value = $this->getAttributeFromArray($key);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        // Check for the presence of an accessor in our model.
        if ($this->hasGetMutator($key)) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            return $this->mutateAttribute($key, $value);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        // If no accessor found, reference our own accessors for relevant date/time fields.
        if (in_array($key, $this->carbonatedAttributes())) {
            $value = $this->returnCarbon ? $this->carbonInstances()->$key : $this->carbonatedAccessor($key);
        }

        // Otherwise, revert to default Eloquent behavour.
        if ($this->hasCast($key)) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            $value = $this->castAttribute($key, $value);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        } elseif (in_array($key, $this->getDates())) {
            if (!is_null($value)) {
                return $this->asDateTime($value);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            }
        }

        return $value;
    }

    /**
     * Override default setAttribute() to include our own mutators.
     *
     * @param string $key
     * @param mixed  $value
     *
     * @return void
     */
    public function setAttribute($key, $value)
    {
        // Check for the presence of a mutator in our model.
        if ($this->hasSetMutator($key)) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            $method = 'set'.studly_case($key).'Attribute';

            return $this->{$method}($value);
        } // If no mutator found, reference our own mutators for relevant date/time fields.
        elseif (in_array($key, $this->carbonatedAttributes())) {
            $value = $this->carbonatedMutator($key, $value);
        } // Otherwise, revert to default Eloquent behavour.
        elseif (in_array($key, $this->getDates()) && $value) {
            $value = $this->fromDateTime($value);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        if ($this->isJsonCastable($key)) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            $value = json_encode($value);
        }

        $this->attributes[$key] = $value;
    }

    /**
     * @param object $carbonInstances
     */
    public function setCarbonInstances($carbonInstances)
    {
        if (!is_object($carbonInstances)) {
            throw new \InvalidArgumentException('carbonInstances must be an object.');
        }
        $this->carbonInstances = $carbonInstances;
    }

    private function ensureProperty($instance, $propertyName)
    {
        if (!property_exists($instance, $propertyName)) {
            return false;
        }

        // Check property value for null and false values
        if (empty($instance->{$propertyName})) {
            return false;
        }

        return true;
    }

    private function useLocalizedFormats()
    {
        $localize = config('carbonated.localization', false);

        return $localize;
    }
}


1			<?php
2
3			namespace ThisVessel;
4
5			use Carbon\Carbon;
6			use Request;
7
8			trait Carbonated
9			{
10			/**
11			* Store carbon instances for reuse.
12			*
13			* @var object
14			*/
15			protected $carbonInstances;
16
17			/**
18			* Indicate whether accessors should be overridden to return carbon instances.
19			*
20			* @var bool
21			*/
22			protected $returnCarbon = false;
23
24			/**
25			* Get the attributes that should be handled as carbonated timestamps.
26			*
27			* @return array
28			*/
29			public function carbonatedTimestamps()
30			{
31			// Add default fields for schema builder's timestamps() and softDeletes().
32			$defaults = [static::CREATED_AT, static::UPDATED_AT, 'deleted_at'];
33
34			return $this->ensureProperty($this, 'carbonatedTimestamps') ? array_unique(array_merge($this->carbonatedTimestamps, $defaults)) : $defaults;
			1 ignored issue – show Bug introduced 2017-04-24 16:52 UTC by Report Bug Copy Issue Report The property `carbonatedTimestamps` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
35			}
36
37			/**
38			* Get the attributes that should be handled as carbonated dates.
39			*

okaufmann / Carbonated

Pull Request — master (#1)

Carbonated::carbonatedAccessor() B

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like