storyday

cos-html-cache is an extremely efficient WordPress page caching plugin designed to make your WordPress site much faster and more responsive. Based on URL rewriting, the plugin will automatically generate real html files for posts when they are loaded for the first time, and automatically renew the html files if their associated posts are modified. 
cos-html-cache. Current version, cos-html-cache2.6, is a huge improvement over previous versions of cos-html-cache.
**** Installation ****
1.Upload to your plugins folder, usually <code>wp-content/plugins/</code> and unzip the file, it will create a <code>wp-content/plugins/cos-html-cache/</code> directory.
2.Activate the plugin on the plugin screen.
3.Make that your perm link looks like a real html file : http://storyday.com/post/xxx.html 
4.create a file named “index.bak” under the root of your web directory
3.done 
**** Uninstallation ****
1.go into admin->options->cos-html-cache 
2.delete all cache files (very important) 
3.go into admin->plugins ,disable cos-html-cache 
4.done.
**** Frequently Asked Questions ****
** Do I really need to use this plugin? **
<ul>
<li>If your site gets Slashdotted</li>
<li>If you’re on a very slow server</li>
<li>If you’ve had a complaint from your host about performance</li>
<li>If you just want to blog rather than testing new plugins and functions of wordpress</li>
</ul>
** How can I tell if it’s working? **
cos-html-cache adds some stats to the very end of a page in the HTML, so you can view source to see if there any codes like ““
** Do you cache other pages such as cat ? **
No,this plugin only cache posts and pages.
**** More Info ****
For more info, please visit http://www.storyday.com/cos-html-cache

****** cos-html-cache ******

cos-html-cache is an extremely efficient WordPress page caching plugin designed to make your WordPress site much faster and more responsive.

Lukas Rydygel

Jinx Fast-Cache provides a very simple but efficient way of full page caching to WordPress. 
It will generate static HTML files which will be called using your servers rewrite rules. 
This feature will bypass the whole PHP process and render only a simple HTML file without the whole overhead.
<h3>Usage</h3>
After activating the plugin, it will modify your .htaccess file. If this is not possible, make sure to enter the rules by yourself:
<pre><code># BEGIN Jinx Fast-Cache
RewriteEngine On
RewriteBase /
RewriteCond %{DOCUMENT_ROOT}/wp-content/jinx-fast-cache/%{HTTP_HOST}/%{REQUEST_URI}/%{QUERY_STRING}/index.html -s
RewriteCond %{REQUEST_METHOD} GET
RewriteRule .* /wp-content/jinx-fast-cache/%{HTTP_HOST}/%{REQUEST_URI}/%{QUERY_STRING}/index.html [L]
# END Jinx Fast-Cache
</code></pre>
When using nginx, make sure to add the following rules:
<pre><code>set $cache_path false;
if ($request_method = GET) {
 set $cache_path /wp-content/jinx-fast-cache/$host/$uri/$args/index.html;
}
location / {
 try_files $cache_path $uri $uri/ /index.php?$query_string;
}
</code></pre>
You may flush, warm or refresh (flush & warm) single or multiple URLs using the buttons in the admin bar.
By default all posts will be automatically warmed after they have been saved and flushed after they have been deleted or put on draft.
The warm process will create a queue, which will be handled in a scheduled task (cron). When warming up a single post, it will skip the queue.
The plugin will automatically flush and warm the cache after an update has been completed.
<h3>Developers</h3>
<h3>Filters</h3>
Jinx Fast-Cache is made for developers. So far no admin panel is available, but you may modify a lot of it’s behaviors using filters.
<ul>
<li>jinx_fast_cache_active: Control if an URL should be cached (default true) or not.</li>
<li>jinx_fast_cache_post_types: Control the post types which should be cached. By default all post types which are “publicly_queryable” and “page” will be cached.</li>
<li>jinx_fast_cache_posts: Filter the posts which should be cached.</li>
<li>jinx_fast_cache_taxonomies: Control the taxonomies which should be cached. By default all taxonomies which are “publicly_queryable” will be cached.</li>
<li>jinx_fast_cache_terms: Filter the terms which should be cached.</li>
<li>jinx_fast_cache_output: Use this to modify the HTML content written to your cache file.</li>
<li>jinx_fast_cache_minify: Control if the output should be minified (default true) or not.</li>
<li>jinx_fast_cache_flush: Control which URLs should be flushed. This may be used to flush related URLs eg. your front page.</li>
<li>jinx_fast_cache_warm: Control which URLs should be warmed. This may be used to warm related URLs eg. your front page.</li>
<li>jinx_fast_cache_queue_interval: Change the interval of the queues cron task (default 60) to warm URLs.</li>
<li>jinx_fast_cache_queue_size: Change the number of URLs which should be handled durring a cron task (default 10). When setting it to <= 0, all URLs will be handled. This may cause a huge load when you have a lot of URLs.</li>
<li>jinx_fast_cache_gc_interval: Change the interval of the GCs cron task (default 60) to flush invalid URLs.</li>
<li>jinx_fast_cache_ignore_404: Control if 404 errors should be cached (default false) or not. Not that a lot of 404 errors will also create a lot of cache files on your server.</li>
<li>jinx_fast_cache_query_params: Control if and which query params will be accepted. You may pass ‘__return_empty_array’ to allow no query params at all.</li>
<li>jinx_fast_cache_refresh_on_upgrade: Control if the cache should be refreshed on upgrade (default true).</li>
<li>jinx_fast_cache_duration: Change the caches duration (default null). The cache of URLs without a duration will always be valid. You may use a numeric value eg. 3600 or something like ’12 hours’ or ‘1 week’ etc.</li>
</ul>
<h3>Injections</h3>
Jinx Fast-Cache also provides the feature to inject dynamic content into your pages. If you eg. want to print the users name on the page, you may inject it via ajax. 
You may also use a placeholder to let your users know, that the content will be loading eg. “loading …”.
Inject a template:
<pre><code>do_action('jinx_fast_cache_inject_template', 'user');
do_action('jinx_fast_cache_inject_template', 'user', 'loading ...');
</code></pre>
This has the same effect as:
<pre><code>do_action('jinx_fast_cache_inject', 'get_template_part', ['user']);
do_action('jinx_fast_cache_inject', 'get_template_part', ['user'], 'loading ...');
</code></pre>
You may call every public function of PHP, your theme or any plugin:
<pre><code>do_action('jinx_fast_cache_inject', 'date', ['Y']);
do_action('jinx_fast_cache_inject', 'my_function', ['param1', 'param2']);
do_action('jinx_fast_cache_inject', 'namespace\MyClass::myMethod', ['param1', 'param2']);
do_action('jinx_fast_cache_inject', ['namespace\MyClass', 'myMethod'], ['param1', 'param2']);
</code></pre>
The first parameter is the function call, the second parameter is an array or arguments passed to this function and the third parameter is the placeholder.
Inside the editor, you may also use shortcodes to inject content.
<pre><code>[jinx_fast_cache_inject]My dynamic content or other shortcodes can be used here[/jinx_fast_cache_inject]
[jinx_fast_cache_inject placeholder="loading..."]My dynamic content or other shortcodes can be used here[/jinx_fast_cache_inject]
</code></pre>
Every shortcode or block between “jinx_fast_cache_inject” will be parsed and injected via ajax. Note that this may cause problems when working with JS events.
<h3>Injection Callbacks</h3>
You may trigger custom JS after dynamic content has been injected.
Using jQuery:
<pre><code>$('.element').on('jinx-fast-cache-inject', function(e) {
 // so smth. with e.target or this
});
</code></pre>
Using VanillaJS:
<pre><code>element.addEventListener('jinx-fast-cache-inject' (e) => {
 // so smth. with e.target
}, false);<h3>Tags</h3>
</code></pre>
Even there are some filters to build a relation between URLs, tags are an easier way to do this. 
You may connect multiple URLs with tags, so if one URL gets flushed, it will also flush URLs with the same tag.
Tags can be used inside the editor by using the shortcode:
<pre><code>[jinx_fast_cache tags="foo,bar"]
</code></pre>
Or you can use it inside your templates by calling the action:
<pre><code>do_action('jinx_fast_cache', ['tags' => 'foo,bar']);
do_action('jinx_fast_cache', ['tags' => ['foo', 'bar']]);
</code></pre>
A usecase for tags might be to connect single posts with your page for posts. So if a single post will be flushed, the page for posts and all other posts will also be flushed.
You may also add multiple tags by calling the shortcode or action multiple times. This will work very well when using blocks or other shortcodes.
<h3>Cache duration</h3>
As you have seen already, you may set a cache duration globally by using the filter ‘jinx_fast_cache_duration’. 
However, if there is a specific URL eg. the front page, you may want to change the duration.
You may use a shortcode like this:
<pre><code>[jinx_fast_cache duration="3600"]
[jinx_fast_cache duration="12 hours"]
</code></pre>
Or you can use it inside your templates by calling the action:
<pre><code>do_action('jinx_fast_cache', ['duration' => 3600]);<h3>Hits</h3>
</code></pre>
Be aware that you can set tags and the cache duration in just one call.
<pre><code>[jinx_fast_cache duration="3600" tags="foo,bar"]
</code></pre>
Or you can use it inside your templates by calling the action:
<pre><code>do_action('jinx_fast_cache', ['duration' => 3600, 'tags' => 'foo,bar']);
do_action('jinx_fast_cache', ['duration' => 3600, 'tags' => ['foo', 'bar']]);
</code></pre>
Note that tags will accept a string or an array.
<h3>Roadmap</h3>
<ul>
<li>[x] Release the plugin</li>
<li>[x] Add HTML minification for output</li>
<li>[x] Allow injection of dynamic rendered templates using ajax requests</li>
<li>[x] Add taxonomies</li>
<li>[x] Provide scheduled tasks</li>
<li>[x] Add admin columns for cache status</li>
<li>[x] Provide exclude option for posts and terms in backend</li>
<li>[x] Add multisite support</li>
<li>[x] Flush and warm after update complete</li>
<li>[x] Add possibility to ignore 404</li>
<li>[x] Allow query params to be excluded or totally ignored</li>
<li>[x] Provide cache duration</li>
<li>[ ] Provide admin panel to change options</li>
<li>[x] Add tags to flush related pages</li>
<li>[x] Add shortcode for injects</li>
<li>[x] Add JS events for injects</li>
</ul>

Jinx Fast-Cache

Jinx Fast-Cache is a blazing fast full page cache for WordPress, written for developers. The goal was to create a caching plugin without the overhead  …

****** cos-html-cache ****** vs Jinx Fast-Cache

cos-html-cache vs Jinx Fast-Cache