JSONStorage.php

Go to the documentation of this file.

<?php
class JSONStorage extends CComponent
{
        const META = 'meta';

        const REGISTRY = 'registry';

        protected $filename = 'registry.json';

        protected $path;

        protected $dirty = false;

        protected $default = "default";

        protected $data = array(
                self::META => array(
                        "updated" => "",
                        "hash" => ""
                ),
                self::REGISTRY => array(
                        /* collection name */
                        "default" => array(
                                "foo" => "bar" /* attributes by example */
                        )
                )
        );

        public function __construct($registry = null)
        {
                if (null === $this->path) {
                        $this->setPath(Yii::app()->getRuntimePath());
                } // JSON storage will be at the app runtime path
                $this->setFile($this->filename);

                $this->load();

                // setup domain
                if ($registry) {
                        if ($this->registryExists($registry) == false) {
                                $this->addRegistry($registry);
                        }
                        $this->default = $registry;
                }
        }

        public function __destruct()
        {
                $this->flush();
        }

        public function onBeforeSave($event)
        {
                $this->raiseEvent('onBeforeSave', $event);
        }

        public function onAfterSave($event)
        {
                $this->raiseEvent('onAfterSave', $event);
        }

        public function setPath($path)
        {
                if (is_dir($path) && is_writable($path)) {
                        $this->path = substr($path, -1) == DIRECTORY_SEPARATOR ? $path : $path . DIRECTORY_SEPARATOR;
                        return true;
                }
                throw new Exception('"Path" must be a writable directory.');
        }

        public function getPath()
        {
                return $this->path;
        }

        public function setFile($file)
        {
                $this->filename = $this->path . $file;
        }

        public function getFile()
        {
                return $this->filename;
        }

        public function verify()
        {
                $registry = function_exists('json_encode')
                        ? json_encode($this->data[self::REGISTRY])
                        : CJSON::encode(
                                $this->data[self::REGISTRY]
                        );
                return $this->data[self::META]["hash"] == md5($registry);
        }

        public function load()
        {
                // load data
                if (file_exists($this->getFile())) {
                        $json = file_get_contents($this->getFile());
                        if (strlen($json) == 0) {
                                return;
                        }

                        $this->data = $this->decode($json);

                        if ($this->data === null) {
                                throw new Exception('Error while trying to decode ' . $this->getFile() . '.');
                        }

                        if (!$this->verify()) {
                                throw new Exception($this->getFile() . ' failed checksum validation.');
                        }
                }
        }

        public function save()
        {
                if ($this->hasEventHandler('onBeforeSave')) {
                        $this->onBeforeSave(new CEvent($this));
                }
                $this->flush();
                if ($this->hasEventHandler('onAfterSave')) {
                        $this->onAfterSave(new CEvent($this));
                }
        }

        public function setData($key, $data, $registry = null)
        {
                if ($registry == null) {
                        $registry = $this->default;
                }
                if (is_string($key . $registry) && $this->registryExists($registry)) {
                        $this->data[self::REGISTRY][$registry][$key] = $data;
                        $this->dirty = true;
                        return true;
                }
                return false;
        }

        public function getData($key, $registry = null)
        {
                if ($registry == null) {
                        $registry = $this->default;
                }
                if (is_string($key . $registry) && $this->registryExists($registry)) {
                        if (array_key_exists($key, $this->data[self::REGISTRY][$registry])) {
                                return $this->data[self::REGISTRY][$registry][$key];
                        }
                }
                return null;
        }

        public function removeData($key, $registry = null)
        {
                if ($registry == null) {
                        $registry = $this->default;
                }

                if (is_string($key . $registry) && $this->registryExists($registry)) {
                        if (array_key_exists($key, $this->data[self::REGISTRY][$registry])) {
                                unset($this->data[self::REGISTRY][$registry][$key]);
                                $this->dirty = true;
                                return true;
                        }
                }
                return false;
        }

        public function getLength($registry = null)
        {
                if ($registry == null) {
                        $registry = $this->default;
                }
                if (is_string($registry) && $this->registryExists($registry)) {
                        return count($this->data[self::REGISTRY][$registry]);
                }
                return 0;
        }

        public function getRegistry($registry)
        {
                return $this->registryExists($registry) ? $this->data[self::REGISTRY][$registry] : null;
        }

        public function registryExists($registry)
        {
                return array_key_exists($registry, $this->data[self::REGISTRY]);
        }

        public function addRegistry($registry)
        {
                if ($this->registryExists($registry)) {
                        return false;
                }
                $this->data[self::REGISTRY][$registry] = array();
                $this->dirty = true;
                return true;
        }

        public function removeRegistry($registry)
        {
                if ($this->registryExists($registry)) {
                        unset($this->data[self::REGISTRY][$registry]);
                        $this->dirty = true;
                        return true;
                }
                return false;
        }

        private function flush()
        {
                // check if writeback is needed
                if ($this->dirty == false) {
                        return true;
                }
                // prepare to writeback to file
                $data = $this->data;
                $registry = $this->encode($this->data[self::REGISTRY]);
                $data[self::META]["updated"] = date("c");
                $data[self::META]["hash"] = md5($registry);

                // overwrite existing data
                if (file_put_contents($this->getFile(), $this->encode($data))) {
                        return true;
                } else {
                        throw new Exception(strtr(
                                'Unable to write back to {FILE}. Data will be lost!',
                                array('{FILE}' => $this->getFile())
                        ));
                }
        }

        private function encode($data)
        {
                return function_exists('json_encode') ? json_encode($data) : CJSON::encode($data);
        }

        private function decode($data)
        {
                return function_exists('json_decode') ? json_decode($data, true) : CJSON::decode($data, true);
        }
}