First

Author: Corey McCormick

.gitignore

@@ -0,0 +1,3 @@
+.idea
+/vendor
+composer.lock

composer.json

@@ -0,0 +1,25 @@
+{
+  "name": "simplesoftwareio/simple-cache",
+  "description": "An easy to use caching trait for Laravel's Eloquent Models.",
+  "license": "MIT",
+  "authors": [
+    {
+      "name": "Simple Software LLC",
+      "email": "support@simplesoftware.io"
+    }
+  ],
+  "minimum-stability": "stable",
+  "require-dev": {
+    "phpunit/phpunit": "5.5.*",
+    "mockery/mockery": "0.9.*"
+  },
+  "autoload": {
+    "psr-4": {
+      "SimpleSoftwareIO\\Cache\\": "src/"
+    }
+  },
+  "require": {
+    "illuminate/database": "~5",
+    "illuminate/cache": "~5"
+  }
+}

phpunit.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit backupGlobals="false"
+         backupStaticAttributes="false"
+         bootstrap="./vendor/autoload.php"
+         colors="true"
+         convertErrorsToExceptions="true"
+         convertNoticesToExceptions="true"
+         convertWarningsToExceptions="true"
+         processIsolation="false"
+         stopOnFailure="false"
+         syntaxCheck="false"
+>
+    <testsuites>
+        <testsuite name="Application Test Suite">
+            <directory>./tests/</directory>
+        </testsuite>
+    </testsuites>
+</phpunit>

src/Cacheable.php

@@ -0,0 +1,111 @@
+<?php
+
+namespace SimpleSoftwareIO\Cache;
+
+trait Cacheable
+{
+    /**
+     * Configures the cache store to be used.
+     *
+     * @var
+     */
+    protected $cacheStore;
+
+    /**
+     * Determines the length to cache a result.
+     *
+     * @var int
+     */
+    protected $cacheLength = 30;
+
+    /**
+     * Determines if the cache should be busted
+     * on inserts/updates/deletes.
+     *
+     * @var bool
+     */
+    protected $cacheBusting = false;
+
+    /**
+     * Overrides the default QueryBuilder to inject the Cache methods
+     *
+     * @return QueryCacheBuilder
+     */
+    protected function newBaseQueryBuilder()
+    {
+        $conn = $this->getConnection();
+
+        $grammar = $conn->getQueryGrammar();
+
+        return new QueryCacheBuilder($this->queryCache(), $conn, $grammar, $conn->getPostProcessor());
+    }
+
+    /**
+     * Generates a new QueryCache
+     *
+     * @return QueryCache
+     */
+    protected function queryCache()
+    {
+        return new QueryCache($this->cacheStore, $this->cacheLength);
+    }
+
+    /**
+     * Flushes the cache on insert/update.
+     *
+     * @param array $options
+     * @return void
+     */
+    public function finishSave(array $options)
+    {
+        if ($this->cacheBusting) {
+            $this->queryCache()->flush($this->getTable());
+        }
+
+        parent::finishSave($options);
+    }
+
+    /**
+     * Flushes the cache on deletes.
+     *
+     * @return bool|null
+     */
+    public function delete()
+    {
+        if ($this->cacheBusting) {
+            $this->queryCache()->flush($this->getTable());
+        }
+
+        return parent::delete();
+    }
+
+    /**
+     * Enables cache busting.
+     *
+     * @return void
+     */
+    public function bust()
+    {
+        $this->cacheBusting = true;
+    }
+
+    /**
+     * Disables cache busting.
+     *
+     * @return void
+     */
+    public function dontBust()
+    {
+        $this->cacheBusting = false;
+    }
+
+    /**
+     * Returns the status of cache busting.
+     *
+     * @return bool
+     */
+    public function isBusting()
+    {
+        return $this->cacheBusting;
+    }
+}

src/QueryCache.php

@@ -0,0 +1,165 @@
+<?php
+
+namespace SimpleSoftwareIO\Cache;
+
+use Illuminate\Cache\TaggableStore;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Support\Facades\Cache;
+
+class QueryCache
+{
+    /**
+     * The cache store to use.
+     *
+     * @var string
+     */
+    protected $store;
+
+    /**
+     * The amount of time to store the cache.
+     *
+     * @var int
+     */
+    protected $length = 30;
+
+    /**
+     * QueryCache constructor.
+     *
+     * @param string $store
+     * @param int $length
+     */
+    public function __construct($store, $length)
+    {
+        $this->store = $store;
+        $this->length = $length;
+    }
+
+    /**
+     * Returns the status of the cache.
+     *
+     * @return bool
+     */
+    public function enabled()
+    {
+        return $this->length === 0 ? false : true;
+    }
+
+    /**
+     * Sets the length of the cache.
+     *
+     * @param int $minutes
+     */
+    public function length($minutes)
+    {
+        $this->length = $minutes;
+    }
+
+    /**
+     * Enables caching on the model.
+     *
+     * @param int $minutes
+     */
+    public function enable($minutes = 30)
+    {
+        $this->length($minutes);
+    }
+
+    /**
+     * Disables the cache on the model.
+     */
+    public function disable()
+    {
+        $this->length = 0;
+    }
+
+    /**
+     * Gets the model results.
+     *
+     * @param QueryCacheBuilder $builder
+     * @param array $columns
+     * @return Collection
+     */
+    public function get(QueryCacheBuilder $builder, $columns = ['*'])
+    {
+        if (! $this->enabled()) return $this->performQuery($builder, $columns);
+
+        $key = $this->generateKey($builder, $columns);
+
+        $cache = $this->getCache($builder);
+
+        return $cache->remember($key, $this->length, function () use ($builder, $columns) {
+            return $this->performQuery($builder, $columns);
+        });
+    }
+
+    /**
+     * Gets a Cache instance
+     *
+     * @return Cache
+     */
+    protected function getCache(QueryCacheBuilder $builder)
+    {
+        return $this->isTaggable() ? Cache::store($this->store)->tags($this->getTag($builder)) : Cache::store($this->store);
+    }
+
+    /**
+     * Determines if the cache store support tagging.
+     *
+     * @return bool
+     */
+    protected function isTaggable()
+    {
+        return Cache::getStore() instanceof TaggableStore;
+    }
+
+    /**
+     * Performs the query on the model.
+     *
+     * @param QueryCacheBuilder $builder
+     * @param array $columns
+     * @return mixed
+     */
+    protected function performQuery(QueryCacheBuilder $builder, $columns = ['*'])
+    {
+        return call_user_func([$builder, 'parent::get'], $columns);
+    }
+
+    /**
+     * Generates the cache key.
+     *
+     * @param QueryCacheBuilder $builder
+     * @param array $columns
+     * @return string
+     */
+    protected function generateKey(QueryCacheBuilder $builder, array $columns)
+    {
+        $sql = $builder->select($columns)->toSql();
+        $whereClause = serialize($builder->getBindings());
+
+        return sha1($sql.$whereClause);
+    }
+
+    /**
+     * Returns the tag to tag a cache.
+     *
+     * @param QueryCacheBuilder $builder
+     * @return string
+     */
+    protected function getTag(QueryCacheBuilder $builder)
+    {
+        return $builder->from;
+    }
+
+    /**
+     * Flushes the cache for a model.
+     *
+     * @param $tag
+     * @return mixed
+     */
+    public function flush($tag)
+    {
+        if ($this->isTaggable()) return Cache::tags($tag)->flush();
+
+        return Cache::flush();
+    }
+}