Recca0120\Twzipcode\Storages\File

Complexity

Total Complexity

28

Size/Duplication

Total Lines	256
Duplicated Lines	2.34 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

97.92%

Importance

Changes	7
Bugs	1	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	2
A	zip3()	0	7	2
A	rules()	0	8	2
B	load()	6	25	3
A	flush()	0	9	1
A	getSource()	0	18	2
A	prepareSource()	0	21	4
A	loadFile()	0	7	2
A	each()	0	10	4
A	compress()	0	4	1
A	decompress()	0	4	1
A	store()	0	9	1
A	restore()	0	14	3

<?php

namespace Recca0120\Twzipcode\Storages;

use ZipArchive;
use Recca0120\Lodash\JArray;
use Recca0120\Twzipcode\Rule;
use Recca0120\Twzipcode\Address;
use Recca0120\Twzipcode\Contracts\Storage;

class File implements Storage
{
    /**
     * $path.
     *
     * @var string
     */
    public $path;

    /**
     * $suffix.
     *
     * @var string
     */
    public $suffix = '.rules';

    /**
     * cached.
     *
     * @var array
     */
    public static $cached = [
        'zip3' => null,
        'zip5' => null,
    ];

    /**
     * __construct.
     *
     * @param string $path
     */
    public function __construct($path = null)
    {
        $this->path = ($path ?: realpath(__DIR__.'/../../resources/data')).'/';
    }

    /**
     * zip3.
     *
     * @param \Recca0120\Twzipcode\Address $address
     * @return string
     */
    public function zip3(Address $address)
    {
        $this->restore('zip3');
        $flat = $address->flat(2);

        return isset(self::$cached['zip3'][$flat]) === true ? self::$cached['zip3'][$flat] : null;
    }

    /**
     * rules.
     *
     * @param string $zip3
     * @return \Recca0120\Lodash\JArray
     */
    public function rules($zip3)
    {
        $this->restore('zip5');

        return isset(self::$cached['zip5'][$zip3]) === true
            ? $this->decompress(self::$cached['zip5'][$zip3])
            : new JArray([]);
    }

    /**
     * load.
     *
     * @param string $source
     * @return $this
     */
    public function load($source)
    {
        $zip5 = new JArray;
        $zip3 = new JArray;
        $this->each($this->prepareSource($source), function ($zipcode, $county, $district, $rules) use ($zip5, $zip3) {
            $zip5[$zipcode] = $this->compress(
                (new JArray($rules))->map(function ($rule) {
                    return new Rule($rule);
                })
            );

            if (isset($zip3[$county]) === false) {
                $zip3[$county] = substr($zipcode, 0, 1);
            }

            if (isset($zip3[$county.$district]) === false) {
                $zip3[$county.$district] = substr($zipcode, 0, 3);
            }
        });

        $this->store('zip3', $zip3);
        $this->store('zip5', $zip5);

        return $this;
    }

    /**
     * loadFile.
     *
     * @param string $file
     * @return $this
     */
    public function loadFile($file = null)
    {
        $file = $file ?: $this->path.'../Zip32_utf8_10501_1.csv';
        $this->load($this->getSource($file));

        return $this;
    }

    /**
     * flush.
     *
     * @return $this
     */
    public function flush()
    {
        static::$cached = [
            'zip3' => null,
            'zip5' => null,
        ];

        return $this;
    }

    /**
     * getSource.
     *
     * @param string $file
     * @return string
     */
    protected function getSource($file)
    {
        $extension = pathinfo($file, PATHINFO_EXTENSION);

        if ($extension === 'zip') {
            $zip = new ZipArchive;
            $zip->open($file);
            $content = $zip->getFromIndex(0);
            $zip->close();
        } else {
            $content = file_get_contents($file);
        }

        $content = mb_convert_encoding($content, 'UTF-8', 'UCS-2LE');
        $content = preg_replace("/^\xEF\xBB\xBF/", '', $content);

        return $content;
    }

    /**
     * prepareSource.
     *
     * @param string $source
     * @return array
     */
    protected function prepareSource($source)
    {
        $tickies = [
            '宜蘭縣壯圍鄉' => '263',
            '新竹縣寶山鄉' => '308',
            '臺南市新市區' => '744',
        ];
        $results = [];
        $rules = preg_split('/\n|\r\n$/', $source);
        foreach ($rules as $rule) {
            if (empty(trim($rule)) === false) {
                list($zipcode, $county, $district) = explode(',', $rule);
                $zip3 = isset($tickies[$county.$district]) === true
                    ? $tickies[$county.$district]
                    : substr($zipcode, 0, 3);
                $results[$county][$district][$zip3][] = $rule;
            }
        }

        return $results;
    }

    /**
     * each.
     *
     * @param array $rules
     * @param \Closure $callback
     */
    protected function each($rules, $callback)
    {
        foreach ($rules as $county => $temp) {
            foreach ($temp as $district => $temp2) {
                foreach ($temp2 as $zipcode => $rules) {
                    $callback($zipcode, $county, $district, $rules);
                }
            }
        }
    }

    /**
     * compress.
     *
     * @param \Recca0120\Lodash\JArray $plainText
     * @return string
     */
    protected function compress($plainText)
    {
        return gzcompress(serialize($plainText));
    }

    /**
     * decompress.
     *
     * @param string $compressed
     * @return mixed
     */
    protected function decompress($compressed)
    {
        return unserialize(gzuncompress($compressed));
    }

    /**
     * store.
     *
     * @param string $filename
     * @param \Recca0120\Lodash\JArray $data
     * @return $this
     */
    protected function store($filename, $data)
    {
        file_put_contents(
            $this->path.$filename.$this->suffix,
            $this->compress($data)
        );

        return $this;
    }

    /**
     * restore.
     *
     * @param string $filename
     * @return mixed
     */
    protected function restore($filename)
    {
        if (file_exists($this->path.$filename.$this->suffix) === false) {
            return false;
        }

        if (is_null(self::$cached[$filename]) === false) {
            return self::$cached[$filename];
        }

        return self::$cached[$filename] = $this->decompress(
            file_get_contents($this->path.$filename.$this->suffix)
        );
    }
}