├── src
    ├── templates
    │   ├── blog-page.html.twig
    │   ├── blog-authors.html.twig
    │   ├── blog-archives.html.twig
    │   ├── blog-tags.html.twig
    │   ├── blog-post.html.twig
    │   └── blog-listings.html.twig
    ├── Twig
    │   ├── Parser.php
    │   ├── Markdown.php
    │   ├── Object.php
    │   ├── Page.php
    │   ├── ExpressionParser.php
    │   └── Theme.php
    ├── Component.php
    └── Blog.php
├── CHANGELOG.md
├── LICENSE.md
├── composer.json
└── README.md


/src/templates/blog-page.html.twig:
--------------------------------------------------------------------------------
1 | {{ content }}
2 | 


--------------------------------------------------------------------------------
/src/Twig/Parser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace BootPress\Blog\Twig;
 4 | 
 5 | class Parser extends \Twig_Parser
 6 | {
 7 |     public function __construct(\Twig_Environment $env)
 8 |     {
 9 |         $this->env = $env;
10 |         $this->expressionParser = new ExpressionParser($this, $this->env);
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/templates/blog-authors.html.twig:
--------------------------------------------------------------------------------
 1 | <ul class="breadcrumb">
 2 | {% for name, href in breadcrumbs %}
 3 |     {% if loop.last %}
 4 |         <li class="active">{{ name }}</li>
 5 |     {% else %}
 6 |         <li><a href="{{ href }}">{{ name }}</a></li>
 7 |     {% endif %}
 8 | {% endfor %}
 9 | </ul>
10 | 
11 | {{ page.set('title', 'Authors @ ' ~ blog.name) }}
12 | 
13 | {% for author in authors %}
14 |     <p><a href="{{ author.url }}">{{ author.name }} <span class="badge">{{ author.count }}</span></a></p>
15 | {% endfor %}


--------------------------------------------------------------------------------
/src/Twig/Markdown.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace BootPress\Blog\Twig;
 4 | 
 5 | use Aptoma\Twig\Extension\MarkdownEngineInterface;
 6 | 
 7 | class Markdown implements MarkdownEngineInterface
 8 | {
 9 |     /**
10 |      * @var \BootPress\Blog\Theme
11 |      */
12 |     private $theme;
13 | 
14 |     public function __construct(Theme $theme)
15 |     {
16 |         $this->theme = $theme;
17 |     }
18 | 
19 |     /**
20 |      * {@inheritdoc}
21 |      */
22 |     public function transform($content)
23 |     {
24 |         return $this->theme->markdown($content);
25 |     }
26 | 
27 |     /**
28 |      * {@inheritdoc}
29 |      */
30 |     public function getName()
31 |     {
32 |         return 'Blog\Markdown';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Twig/Object.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace BootPress\Blog\Twig;
 4 | 
 5 | class Object
 6 | {
 7 |     public $properties = array();
 8 |     public $methods = array();
 9 | 
10 |     public function __construct(array $properties = array(), array $methods = array())
11 |     {
12 |         $this->properties = $properties;
13 |         $this->methods = $methods;
14 |     }
15 | 
16 |     public function __get($name)
17 |     {
18 |         return (isset($this->properties[$name])) ? $this->properties[$name] : null;
19 |     }
20 | 
21 |     public function __isset($name)
22 |     {
23 |         return (isset($this->methods[$name])) ? false : true;
24 |     }
25 | 
26 |     public function __call($name, $arguments)
27 |     {
28 |         if (isset($this->methods[$name]) && is_callable($this->methods[$name])) {
29 |             return call_user_func_array($this->methods[$name], $arguments);
30 |         }
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Twig/Page.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace BootPress\Blog\Twig;
 4 | 
 5 | use BootPress\Page\Component as PageClone;
 6 | 
 7 | class Page
 8 | {
 9 |     public $methods = array();
10 | 
11 |     public function __construct()
12 |     {
13 |         $page = PageClone::html();
14 |         foreach (array('set', 'url', 'get', 'post', 'tag', 'meta', 'link', 'style', 'script', 'jquery', 'id') as $name) {
15 |             $this->methods[$name] = array($page, $name);
16 |         }
17 |     }
18 | 
19 |     public function __get($name)
20 |     {
21 |         return PageClone::html()->$name;
22 |     }
23 | 
24 |     public function __isset($name)
25 |     {
26 |         return (isset($this->methods[$name])) ? false : true;
27 |     }
28 | 
29 |     public function __call($name, $arguments)
30 |     {
31 |         if (isset($this->methods[$name]) && is_callable($this->methods[$name])) {
32 |             return call_user_func_array($this->methods[$name], $arguments);
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Change Log
 2 | All notable changes to this project will be documented in this file.
 3 | 
 4 | The format is based on [Keep a Changelog](http://keepachangelog.com/) 
 5 | and this project adheres to [Semantic Versioning](http://semver.org/).
 6 | 
 7 | ## [Unreleased]
 8 | 
 9 | ## [1.4] - 2017-01-08
10 | ### Added
11 | - ParsedownExtra as default markdown provider
12 | - Custom callable markdown implementations
13 | 
14 | ## [1.3] - 2017-01-04
15 | ### Added
16 | - Microtimes to Twig templates debug data
17 | - Static Theme dumper method
18 | 
19 | ## [1.2] - 2016-11-29
20 | ### Added
21 | - Twig dir function for relative paths
22 | 
23 | ### Changed
24 | - Only save html pages in database
25 | 
26 | ### Fixed
27 | - Empty category undefined offset
28 | 
29 | ## [1.1] - 2016-10-25
30 | ### Added
31 | - Optionally specify Twig array keys via '**:**' colon, similar to hashes
32 | - Improved Global Vars Dump
33 | 
34 | ### Fixed
35 | - Relative asset paths for Twig v1.27.0
36 | 
37 | ## [1.0] - 2016-10-13
38 | - Initial Release
39 | 


--------------------------------------------------------------------------------
/src/templates/blog-archives.html.twig:
--------------------------------------------------------------------------------
 1 | <ul class="breadcrumb">
 2 | {% for name, href in breadcrumbs %}
 3 |     {% if loop.last %}
 4 |         <li class="active">{{ name }}</li>
 5 |     {% else %}
 6 |         <li><a href="{{ href }}">{{ name }}</a></li>
 7 |     {% endif %}
 8 | {% endfor %}
 9 | </ul>
10 | 
11 | {{ page.set('title', 'The Archives @ ' ~ blog.name) }}
12 | 
13 | {% for Y, years in archives|reverse(true) %}
14 | 
15 |     <h3><a href="{{ years.url }}">{{ Y }} <span class="label label-primary pull-right">{{ years.count }}</span></a></h3>
16 |     
17 |     <div class="row" style="font-size:20px;">
18 |     {% set columns = [] %}
19 |     {% for M, months in years.months %}
20 |         <div class="col-xs-3 col-md-2 col-lg-1 center-block" style="height:100px;">
21 |             <p class="text-center">
22 |                 <a href="{{ months.url }}">{{ M }}
23 |                 {% if months.count > 0 %}
24 |                     <br><span class="label label-primary">{{ months.count }}</span>
25 |                 {% endif %}
26 |                 </a>
27 |             </p>
28 |         </div>
29 |     {% endfor %}
30 |     </div>
31 |     
32 | {% endfor %}


--------------------------------------------------------------------------------
/src/templates/blog-tags.html.twig:
--------------------------------------------------------------------------------
 1 | <ul class="breadcrumb">
 2 | {% for name, href in breadcrumbs %}
 3 |     {% if loop.last %}
 4 |         <li class="active">{{ name }}</li>
 5 |     {% else %}
 6 |         <li><a href="{{ href }}">{{ name }}</a></li>
 7 |     {% endif %}
 8 | {% endfor %}
 9 | </ul>
10 | 
11 | {{ page.set('title', 'Tag Cloud @ ' ~ blog.name) }}
12 | 
13 | <p>
14 | {% for tag in tags %}
15 |     {% if tag.rank == 1 %}
16 |         <a class="text-primary" style="font-size:15px; padding:0px 5px;" href="{{ tag.url }}">{{ tag.name }}</a>
17 |     {% elseif tag.rank == 2 %}
18 |         <a class="text-info" style="font-size:18px; padding:0px 5px;" href="{{ tag.url }}">{{ tag.name }}</a>
19 |     {% elseif tag.rank == 3 %}
20 |         <a class="text-success" style="font-size:21px; padding:0px 5px;" href="{{ tag.url }}">{{ tag.name }}</a>
21 |     {% elseif tag.rank == 4 %}
22 |         <a class="text-warning" style="font-size:24px; padding:0px 5px;" href="{{ tag.url }}">{{ tag.name }}</a>
23 |     {% elseif tag.rank == 5 %}
24 |         <a class="text-danger" style="font-size:27px; padding:0px 5px;" href="{{ tag.url }}">{{ tag.name }}</a>
25 |     {% endif %}
26 | {% endfor %}
27 | </p>
28 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | # The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Kyle Gadd <kyle.gadd@gmail.com>
 4 | 
 5 | > Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | > of this software and associated documentation files (the "Software"), to deal
 7 | > in the Software without restriction, including without limitation the rights
 8 | > to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | > copies of the Software, and to permit persons to whom the Software is
10 | > furnished to do so, subject to the following conditions:
11 | >
12 | > The above copyright notice and this permission notice shall be included in
13 | > all copies or substantial portions of the Software.
14 | >
15 | > THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | > IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | > FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | > AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | > LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | > OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | > THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/templates/blog-post.html.twig:
--------------------------------------------------------------------------------
 1 | <ul class="breadcrumb">
 2 | {% for name, href in breadcrumbs %}
 3 |     {% if loop.last %}
 4 |         <li class="active">&nbsp;</li>
 5 |     {% else %}
 6 |         <li><a href="{{ href }}">{{ name }}</a></li>
 7 |     {% endif %}
 8 | {% endfor %}
 9 | </ul>
10 | 
11 | <article itemscope itemtype="http://schema.org/Article">
12 | 
13 |     <div class="page-header"><h1 itemprop="name">{{ post.title }}</h1></div>
14 |     
15 |     <p>
16 |         Published: <a itemprop="datePublished" href="{{ post.archive }}">{{ post.published|date('F j, Y') }}</a>
17 |         {% if post.author %}
18 |             by <a itemprop="author" href="{{ post.author.url }}">{{ post.author.name }}</a>
19 |         {% endif %}
20 |     </p>
21 |     
22 |     <div itemprop="articleBody" style="padding-bottom:40px;">{{ post.content }}</div>
23 |     
24 |     {% for tag in post.tags %}
25 |         {% if loop.first %}
26 |             <p>Tagged:
27 |         {% endif %}
28 |         
29 |         &nbsp;<a itemprop="keywords" href="{{ tag.url }}">{{ tag.name }}</a>
30 |         
31 |         {% if loop.last %}
32 |             </p>
33 |         {% endif %}
34 |     {% endfor %}
35 |     
36 | </article>
37 | 
38 | {{ pagination.pager(post.previous, post.next) }}
39 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "bootpress/blog",
 3 |     "description": "A flat file Blog and CMS that doesn't skimp on features, and can be utilized in any website.",
 4 |     "keywords": ["bootpress", "blog", "flat-file", "cms", "twig", "markdown"],
 5 |     "homepage": "https://www.bootpress.org/components/blog.html",
 6 |     "license": "MIT",
 7 |     "authors": [
 8 |         {
 9 |             "name": "Kyle Gadd",
10 |             "email": "kyle.gadd@gmail.com"
11 |         }
12 |     ],
13 |     "require": {
14 |         "php": ">=5.4",
15 |         "bootpress/page": "^1.0",
16 |         "bootpress/asset": "^1.0",
17 |         "bootpress/sqlite": "^1.0",
18 |         "bootpress/sitemap": "^1.0",
19 |         "bootpress/hierarchy": "^1.0",
20 |         "bootpress/pagination": "^1.0",
21 |         "symfony/var-dumper": "^2.3||^3.0",
22 |         "symfony/finder": "^2.3||^3.0",
23 |         "symfony/yaml": "^2.3||^3.0",
24 |         "jbroadway/urlify": "^1.0",
25 |         "xsirix/phpuri": "^1.0",
26 |         "spartz/text-formatter": "^1.0",
27 |         "aptoma/twig-markdown": "^2.0",
28 |         "erusev/parsedown-extra": "^0.7",
29 |         "twig/twig": "^1.27"
30 |     },
31 |     "require-dev": {
32 |         "bootpress/htmlunit": "^1.0",
33 |         "friendsofphp/php-cs-fixer": "^1.0",
34 |         "squizlabs/php_codesniffer": "^2.5"
35 |     },
36 |     "autoload": {
37 |         "psr-4": { "BootPress\\Blog\\": "src" }
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Twig/ExpressionParser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace BootPress\Blog\Twig;
 4 | 
 5 | use Twig_Token;
 6 | use Twig_Node_Expression_Array;
 7 | 
 8 | class ExpressionParser extends \Twig_ExpressionParser
 9 | {
10 |     public function parseArrayExpression()
11 |     {
12 |         $stream = $this->parser->getStream();
13 |         $stream->expect(Twig_Token::PUNCTUATION_TYPE, '[', 'An array element was expected');
14 | 
15 |         $node = new Twig_Node_Expression_Array(array(), $stream->getCurrent()->getLine());
16 |         $first = true;
17 |         while (!$stream->test(Twig_Token::PUNCTUATION_TYPE, ']')) {
18 |             if (!$first) {
19 |                 $stream->expect(Twig_Token::PUNCTUATION_TYPE, ',', 'An array element must be followed by a comma');
20 | 
21 |                 // trailing ,?
22 |                 if ($stream->test(Twig_Token::PUNCTUATION_TYPE, ']')) {
23 |                     break;
24 |                 }
25 |             }
26 |             $first = false;
27 | 
28 |             // $node->addElement($this->parseExpression());
29 |             $value = $this->parseExpression();
30 |             if ($stream->test(Twig_Token::PUNCTUATION_TYPE, ':')) {
31 |                 $stream->expect(Twig_Token::PUNCTUATION_TYPE, ':');
32 |                 $node->addElement($this->parseExpression(), $value);
33 |             } else {
34 |                 $node->addElement($value);
35 |             }
36 |         }
37 |         $stream->expect(Twig_Token::PUNCTUATION_TYPE, ']', 'An opened array is not properly closed');
38 | 
39 |         return $node;
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/templates/blog-listings.html.twig:
--------------------------------------------------------------------------------
 1 | <ul class="breadcrumb">
 2 | {% for name, href in breadcrumbs %}
 3 |     {% if loop.last %}
 4 |         {% if search %}
 5 |             <li class="active">Search: {{ search|escape }}</li>
 6 |         {% else %}
 7 |             <li class="active">{{ name }}</li>
 8 |         {% endif %}
 9 |     {% else %}
10 |         <li><a href="{{ href }}">{{ name }}</a></li>
11 |     {% endif %}
12 | {% endfor %}
13 | </ul>
14 | 
15 | {% if search %}
16 | 
17 |     {% if blog.page == 'index' %}
18 |         
19 |         {{ page.set('title', 'Search: ' ~ search|escape('html_attr') ~ ' @ ' ~ blog.name) }}
20 |         
21 |     {% elseif blog.page == 'category' %}
22 |         
23 |         {{ page.set('title', 'Search: ' ~ search|escape('html_attr') ~ ' @ ' ~ category|join(' &raquo; ')) }}
24 |         
25 |     {% endif %}
26 | 
27 | {% elseif blog.page == 'index' %}
28 | 
29 |     {{ page.set('title', blog.name) }}
30 |     
31 | {% elseif blog.page == 'category' %}
32 | 
33 |     {{ page.set('title', category|join(' &raquo; ') ~ ' @ ' ~ blog.name) }}
34 | 
35 | {% elseif blog.page == 'archives' %}
36 |     
37 |     {% if archive|length == 4 %}
38 |         {% set date = archive.date|date('F j, Y') %}
39 |     {% elseif archive|length == 3 %}
40 |         {% set date = archive.date|date('F Y') %}
41 |     {% elseif archive|length == 2 %}
42 |         {% set date = archive.date|date('Y') %}
43 |     {% endif %}
44 |     
45 |     {{ page.set('title', date ~ ' Archives @ ' ~ blog.name) }}
46 |     
47 | {% elseif blog.page == 'authors' %}
48 | 
49 |     {{ page.set('title', author.name ~ ' @ ' ~ blog.name) }}
50 |     
51 | {% elseif blog.page == 'tags' %}
52 | 
53 |     {{ page.set('title', tag.name ~ ' @ ' ~ blog.name) }}
54 |     
55 | {% endif %}
56 | 
57 | {% if not pagination.set('page', 10) %}
58 |     {{ pagination.total(blog.query(listings, 'count')) }}
59 | {% endif %}
60 | 
61 | {% set posts = blog.query(listings, pagination) %}
62 | 
63 | {% for post in posts %}
64 | 
65 |     <article itemscope itemtype="http://schema.org/Article">
66 |     
67 |         <h2 itemprop="name"><a href="{{ post.url }}">{{ post.title }}</a></h2>
68 |         
69 |         <p>
70 |             {% if post.page.image %}
71 |                 <a href="{{ post.url }}"><img itemprop="image" src="{{ post.page.image }}?w=250&h=200" alt="{{ post.title }}" class="img-responsive" style="float:left; margin-right:15px;"></a>
72 |             {% endif %}
73 |             {% if search %}
74 |                 {{ post.snippet }}
75 |             {% else %}
76 |                 <span itemprop="headline">{{ post.content|striptags|length > 500 ? post.content|striptags|slice(0,500) ~ '&hellip;' : post.content|striptags }}</span>
77 |             {% endif %}
78 |         </p>
79 |         
80 |         <a href="{{ post.url }}">Read more &rarr;</a>
81 |         
82 |     </article>
83 |     
84 | {% endfor %}
85 | 
86 | {{ pagination.pager() }}
87 | 


--------------------------------------------------------------------------------
/src/Component.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace BootPress\Blog;
  4 | 
  5 | use BootPress\Page\Component as Page;
  6 | use BootPress\Sitemap\Component as Sitemap;
  7 | use BootPress\Hierarchy\Component as Hierarchy;
  8 | 
  9 | /**
 10 |  * A flat file Blog and CMS that doesn't skimp on features, and can be utilized in any website.
 11 |  */
 12 | class Component extends Blog
 13 | {
 14 |     /**
 15 |      * Determine if there is any Blog content associated with the current url path.
 16 |      * 
 17 |      * @return mixed Either ``false`` if there is not a corresponding ``$page->url['path']`` Twig template, a string if ``$page->url['format'] != 'html'``, or an array suitable for passing to ``$blog->theme->renderTwig($file)`` with the following keys:
 18 |      *
 19 |      * - '**file**' => The appropriate Twig template that is equipped to deal with these '**type**' of '**vars**'.
 20 |      * - '**type**' => The kind of Blog page you are working with.  Either *'page'*, *'post'*, *'category'*, *'index'*, *'archives'*, *'authors'*, or *'tags'*.
 21 |      * - '**vars**' => For the Twig template to utilize.
 22 |      * - '**default**' => An alternate '**file**' to use if it's missing in your theme.
 23 |      *
 24 |      * ```php
 25 |      * if (is_array($file = $blog->page())) { // An 'index.html.twig' file
 26 |      *     $html = $blog->theme->renderTwig($file);
 27 |      * } elseif ($file !== false) { // A 'txt', 'json', 'xml', 'rdf', 'rss', or 'atom' page
 28 |      *     $page->send(Asset::dispatch($page->url['format'], $file));
 29 |      * }
 30 |      * ```
 31 |      */
 32 |     public function page()
 33 |     {
 34 |         $page = Page::html();
 35 |         $listings = $this->config('blog', 'listings');
 36 |         if ($page->url['format'] != 'html') {
 37 |             $file = (preg_match('/\.(txt|json|xml|rdf|rss|atom)$/', $page->url['path'])) ? $this->folder.'content/'.$page->url['path'].'.twig' : null;
 38 | 
 39 |             return (is_file($file)) ? trim($this->theme->renderTwig($file)) : false;
 40 |         } elseif ($id = $this->file($page->url['path'])) {
 41 |             $params = array('id' => $id, 'path' => $page->url['path']);
 42 |             $method = 'blog';
 43 |         } elseif ($route = $page->routes(array(
 44 |             $listings,
 45 |             $listings.'/[archives:path]/[i:year]?/[i:month]?/[i:day]?',
 46 |             $listings.'/[authors|tags:path]/[:name]?',
 47 |             '[**:category]',
 48 |         ))) {
 49 |             $params = $route['params'];
 50 |             $method = (isset($params['path'])) ? $params['path'] : 'listings';
 51 |             if ($method == 'listings' && $search = $page->request->query->get('search')) {
 52 |                 $params['search'] = $search;
 53 |             }
 54 |         }
 55 |         if (!isset($method) || (isset($params['category']) && !is_dir($this->folder.'content/'.$params['category']))) {
 56 |             $template = false;
 57 |         } elseif ($template = $this->$method($params)) {
 58 |             $template = array_combine(array('file', 'type', 'vars'), $template);
 59 |             $template['default'] = __DIR__.'/templates/';
 60 |             $this->theme->vars['blog']->properties['page'] = $template['type'];
 61 |         }
 62 | 
 63 |         return $template;
 64 |     }
 65 | 
 66 |     private function blog($params, array $vars = array())
 67 |     {
 68 |         $page = Page::html();
 69 |         extract($params); // 'id' and 'path'
 70 |         $page->enforce($path);
 71 |         $info = $this->info($id);
 72 |         if (is_bool($info['published'])) {
 73 |             return array('blog-page.html.twig', 'post', $info);
 74 |         }
 75 |         $vars['post'] = $info;
 76 |         if ($search = $page->request->query->get('search')) {
 77 |             $sitemap = new Sitemap();
 78 |             if ($docid = $sitemap->db->value('SELECT docid FROM sitemap WHERE path = ?', $path)) {
 79 |                 $words = $sitemap->words($search, $docid);
 80 |                 if (!empty($words)) {
 81 |                     $vars['search'] = $words;
 82 |                 }
 83 |             }
 84 |             unset($sitemap);
 85 |         }
 86 |         $vars['breadcrumbs'] = $this->breadcrumbs();
 87 |         foreach ($vars['post']['categories'] as $category) {
 88 |             $vars['breadcrumbs'][$category['name']] = $category['url'];
 89 |         }
 90 |         $vars['breadcrumbs'][$vars['post']['title']] = $vars['post']['url'];
 91 | 
 92 |         return array('blog-post.html.twig', 'post', $vars);
 93 |     }
 94 | 
 95 |     private function listings($params, array $vars = array())
 96 |     {
 97 |         $page = Page::html();
 98 |         extract($params); // 'path'?, 'category'? and 'search'?
 99 |         if (isset($category)) {
100 |             $url = $page->url('base', $category);
101 |         } else {
102 |             $url = $page->url('blog/listings');
103 |         }
104 |         $page->enforce($url);
105 |         $type = (isset($category)) ? 'category' : 'index';
106 |         $vars['listings'] = array();
107 |         $vars['breadcrumbs'] = $this->breadcrumbs();
108 |         if (isset($category)) {
109 |             $hier = new Hierarchy($this->db, 'categories');
110 |             $path = $hier->path('path', $category, array('path', 'name'));
111 |             if (empty($path)) {
112 |                 return false;
113 |             }
114 |             $tree = $hier->tree(array('path', 'name'), 'path', $category);
115 |             $counts = $hier->counts('blog', 'category_id');
116 |             foreach ($tree as $id => $fields) {
117 |                 $tree[$id]['count'] = (isset($counts[$id])) ? $counts[$id] : 0;
118 |             }
119 |             foreach ($path as $row) {
120 |                 $vars['category'][] = $row['name'];
121 |                 $vars['breadcrumbs'][$row['name']] = $page->url('base', $row['path']);
122 |             }
123 |             $vars['categories'] = $this->query('categories', array('nest' => $hier->nestify($tree), 'tree' => $tree));
124 |             $vars['listings']['categories'] = array_keys($tree);
125 |         }
126 |         if (isset($search) && !empty($search)) {
127 |             $vars['search'] = $search;
128 |             $vars['breadcrumbs']['Search'] = $page->url('add', $url, 'search', $search);
129 |             $vars['listings']['search'] = $search;
130 |         }
131 | 
132 |         return array('blog-listings.html.twig', $type, $vars);
133 |     }
134 | 
135 |     private function archives($params, array $vars = array())
136 |     {
137 |         $page = Page::html();
138 |         list($path, $Y, $m, $d) = array_pad(array_values($params), 4, '');
139 |         if (!empty($d)) {
140 |             list($from, $to) = $this->range($Y, $m, $d);
141 |             $page->enforce($page->url('blog/listings', $path, date('/Y/m/d', $from)));
142 |             $vars['archive'] = array_combine(array('date', 'year', 'month', 'day'), explode(' ', date($from.' Y F j', $from)));
143 |             $vars['breadcrumbs'] = $this->breadcrumbs(array(
144 |                 'Archives' => $path,
145 |                 $vars['archive']['year'] => $Y,
146 |                 $vars['archive']['month'] => $m,
147 |                 $vars['archive']['day'] => $d,
148 |             ));
149 |         } elseif (!empty($m)) {
150 |             list($from, $to) = $this->range($Y, $m);
151 |             $page->enforce($page->url('blog/listings', $path, date('/Y/m', $from)));
152 |             $vars['archive'] = array_combine(array('date', 'year', 'month'), explode(' ', date($from.' Y F', $from)));
153 |             $vars['breadcrumbs'] = $this->breadcrumbs(array(
154 |                 'Archives' => $path,
155 |                 $vars['archive']['year'] => $Y,
156 |                 $vars['archive']['month'] => $m,
157 |             ));
158 |         } elseif (!empty($Y)) {
159 |             list($from, $to) = $this->range($Y);
160 |             $page->enforce($page->url('blog/listings', $path, date('/Y', $from)));
161 |             $vars['archive'] = array_combine(array('date', 'year'), explode(' ', date($from.' Y', $from)));
162 |             $vars['breadcrumbs'] = $this->breadcrumbs(array(
163 |                 'Archives' => $path,
164 |                 $vars['archive']['year'] => $Y,
165 |             ));
166 |         } else {
167 |             $page->enforce($page->url('blog/listings', $path));
168 |             $vars['archives'] = $this->query('archives');
169 |             $vars['breadcrumbs'] = $this->breadcrumbs(array(
170 |                 'Archives' => $path,
171 |             ));
172 | 
173 |             return array('blog-archives.html.twig', 'archives', $vars);
174 |         }
175 |         $vars['listings']['archives'] = array($from, $to);
176 | 
177 |         return array('blog-listings.html.twig', 'archives', $vars);
178 |     }
179 | 
180 |     private function authors($params, array $vars = array())
181 |     {
182 |         $page = Page::html();
183 |         extract($params); // 'path' and 'name'?
184 |         $vars['breadcrumbs'] = $this->breadcrumbs(array('Authors' => $path));
185 |         if (!isset($name)) { // just authors, no posts
186 |             $page->enforce($page->url('blog/listings', $path));
187 |             $vars['authors'] = $this->query('authors');
188 | 
189 |             return array('blog-authors.html.twig', 'authors', $vars);
190 |         }
191 |         $vars['author'] = $this->query('authors', $name);
192 |         if (empty($vars['author'])) {
193 |             $page->eject($page->url('blog/listings', $path));
194 | 
195 |             return false;
196 |         }
197 |         $vars['breadcrumbs'][$vars['author']['name']] = $page->url('blog/listings', $path, $vars['author']['path']);
198 |         $vars['listings']['count'] = $vars['author']['count'];
199 |         $vars['listings']['authors'] = $name;
200 | 
201 |         return array('blog-listings.html.twig', 'authors', $vars);
202 |     }
203 | 
204 |     private function tags($params, array $vars = array())
205 |     {
206 |         $page = Page::html();
207 |         extract($params); // 'path' and 'name'?
208 |         $vars['breadcrumbs'] = $this->breadcrumbs(array('Tags' => $path));
209 |         if (!isset($name)) { // search all tags and get a frequency count
210 |             $page->enforce($page->url('blog/listings', $path));
211 |             $vars['tags'] = $this->query('tags');
212 | 
213 |             return array('blog-tags.html.twig', 'tags', $vars);
214 |         }
215 |         $vars['tag'] = $this->query('tags', $name);
216 |         if (empty($vars['tag'])) {
217 |             $page->eject($page->url('blog/listings', $path));
218 | 
219 |             return false;
220 |         }
221 |         $vars['breadcrumbs'][$vars['tag']['name']] = $page->url('blog/listings', $path, $vars['tag']['path']);
222 |         $vars['listings']['count'] = $vars['tag']['count'];
223 |         $vars['listings']['tags'] = $vars['tag']['path'];
224 | 
225 |         return array('blog-listings.html.twig', 'tags', $vars);
226 |     }
227 | 
228 |     private function breadcrumbs(array $links = array())
229 |     {
230 |         $breadcrumbs = array();
231 |         $breadcrumbs[$this->config('blog', 'breadcrumb')] = Page::html()->url('blog/listings');
232 |         $previous = '';
233 |         foreach ($links as $name => $path) {
234 |             $breadcrumbs[$name] = Page::html()->url('blog/listings', $previous.$path);
235 |             $previous .= $path.'/';
236 |         }
237 | 
238 |         return $breadcrumbs;
239 |     }
240 | 
241 |     private function range($Y, $m = null, $d = null)
242 |     {
243 |         if (!empty($d)) {
244 |             $from = mktime(0, 0, 0, (int) $m, (int) $d, (int) $Y);
245 |             $to = mktime(23, 59, 59, (int) $m, (int) $d, (int) $Y);
246 |         } elseif (!empty($m)) {
247 |             $from = mktime(0, 0, 0, (int) $m, 1, (int) $Y);
248 |             $to = mktime(23, 59, 59, (int) $m + 1, 0, (int) $Y);
249 |         } else {
250 |             $from = mktime(0, 0, 0, 1, 1, (int) $Y);
251 |             $to = mktime(23, 59, 59, 1, 0, (int) $Y + 1);
252 |         }
253 | 
254 |         return array($from, $to);
255 |     }
256 | }
257 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # use BootPress\Blog\Component as Blog;
  2 | 
  3 | [![Packagist][badge-version]][link-packagist]
  4 | [![License MIT][badge-license]](LICENSE.md)
  5 | [![HHVM Tested][badge-hhvm]][link-travis]
  6 | [![PHP 7 Supported][badge-php]][link-travis]
  7 | [![Build Status][badge-travis]][link-travis]
  8 | [![Code Climate][badge-code-climate]][link-code-climate]
  9 | [![Test Coverage][badge-coverage]][link-coverage]
 10 | 
 11 | A flat file Blog and CMS that doesn't skimp on features, and can be utilized in any website.
 12 | 
 13 | ## Installation
 14 | 
 15 | Add the following to your ``composer.json`` file.
 16 | 
 17 | ``` bash
 18 | {
 19 |     "require": {
 20 |         "bootpress/blog": "^1.0"
 21 |     }
 22 | }
 23 | ```
 24 | 
 25 | Create an ``.htaccess`` file in your website's public root folder to redirect everything that doesn't exist to an ``index.php`` file.
 26 | 
 27 | ```htaccess
 28 | # Prevent directory browsing
 29 | Options All -Indexes
 30 | 
 31 | # Turn on URL re-writing (remove 'example.com/' if not on localhost)
 32 | RewriteEngine On
 33 | RewriteBase /example.com/
 34 | 
 35 | # If the file exists, then that's all folks
 36 | RewriteCond %{REQUEST_FILENAME} -f
 37 | RewriteRule .+ - [L]
 38 | 
 39 | # For everything else, there's BootPress
 40 | RewriteRule ^(.*)$ index.php [L]
 41 | ```
 42 | 
 43 | Your ``index.php`` file should then look something like this:
 44 | 
 45 | ```php
 46 | <?php
 47 | 
 48 | use BootPress\Page\Component as Page;
 49 | use BootPress\Blog\Component as Blog;
 50 | use BootPress\Asset\Component as Asset;
 51 | use BootPress\Sitemap\Component as Sitemap;
 52 | 
 53 | $autoloader = require '../vendor/autoload.php';
 54 | 
 55 | // Setup the page
 56 | $page = Page::html(array(
 57 |     'dir' => '../page', // a private (root) directory
 58 |     'base' => 'http://localhost/example.com',
 59 |     'suffix' => '.html',
 60 | ));
 61 | $html = '';
 62 | 
 63 | // Deliver sitemap and assets first
 64 | if ($asset = Asset::cached('assets')) {
 65 |     $page->send($asset);
 66 | } elseif ($xml = Sitemap::page()) {
 67 |     $page->send($xml);
 68 | }
 69 | 
 70 | // Implement a blog
 71 | $blog = new Blog();
 72 | if (false !== $file = $blog->page()) {
 73 |     if (is_array($file)) { // An 'index.html.twig' file
 74 |         $html = $blog->theme->renderTwig($file);
 75 |     } else { // A 'txt', 'json', 'xml', 'rdf', 'rss', or 'atom' page
 76 |         $page->send(Asset::dispatch($page->url['format'], $file));
 77 |     }
 78 | } else {
 79 |     $page->send(404);
 80 | }
 81 | 
 82 | // Create the layout
 83 | $html = $page->display($blog->theme->layout($html));
 84 | 
 85 | // Send to user
 86 | $page->send(Asset::dispatch('html', $html));
 87 | ```
 88 | 
 89 | ## Setup Blog
 90 | 
 91 | Create a ``../page/blog/config.yml`` file with the following information:
 92 | 
 93 | ```yaml
 94 | blog:
 95 |     name: Example # The name of your website
 96 |     image: logo.png # The main image relative to this directory
 97 |     listings: blog # The url base for all your listing pages - authors, archives, tags, etc.
 98 |     breadcrumb: Blog # How to reference the listings in your breadcrumbs array
 99 |     theme: default # The main theme for your site
100 | ```
101 | 
102 | You can access any of these in your Twig templates eg. ``{{ blog.name }}``, including the ``{{ blog.page }}`` you are on.  Eventually this file will be full of authors, categories, and tags that you can easily manage as well.  You can create a [Bootstrap list group](http://getbootstrap.com/components/#list-group) of categories by:
103 | 
104 | ```twig
105 | <ul class="list-group">
106 | {% for category in blog.query('categories') %}
107 |     <li class="list-group-item">
108 |         <span class="badge">{{ category.count }}</span>
109 |         <a href="{{ category.url }}">{{ category.name }}</a>
110 |         {# if category.subs #}
111 |     </li>
112 | {% endfor %}
113 | </ul>
114 | ```
115 | 
116 | Other ``{{ blog.query(...) }}``'s include '**tags**', '**authors**', '**archives**', '**recent**', '**featured**', '**similar**', '**posts**', and **[...]** listings of every sort, otherwise known as "The Loop".
117 | 
118 | ## Create Content
119 | 
120 | A BootPress Blog is a flat-file CMS, which means you don't need any fancy admin interface to manage all of the content that is scattered througout a database.  You simply create files.  All of your blog's posts and pages will reside in the ``../page/blog/content/`` directory, and if you look at a URL, you will be able to follow the folders straight to your ``index.html.twig`` file. For example:
121 | 
122 | | URL                                   | File                                                         |
123 | | ------------------------------------- | ------------------------------------------------------------ |
124 | | /                                     | blog/content/index.html.twig                                 |
125 | | /feed.rss                             | blog/content/feed.rss.twig                                   |
126 | | /about-me.html                        | blog/content/about-me/index.html.twig                        |
127 | | /category/post.html                   | blog/content/category/post/index.html.twig                   |
128 | | /category/subcategory/long-title.html | blog/content/category/subcategory/long-title/index.html.twig |
129 | 
130 | Why not have the '**/about-me.html**' URL file at '**content/about-me.html.twig**' instead of '**content/about-me/index.html.twig**' instead, right? This is so you can have all of the assets that you want to use, right there where you want to use them.  Linking to them is even easier.  Place an '**image.jpg**' in the '**content/about-me/**' folder, and link to ``{{ 'image.jpg'|asset }}`` in the '**index.html.twig**' file. Would you like to resize that?  Try an ``{{ 'image.jpg?w=300'|asset }}``. To see all the options, check out the [Quick Reference "Glide"](http://glide.thephpleague.com/1.0/api/quick-reference/).
131 | 
132 | Non-HTML files are accessed according to the '**/feed.rss**' URL example above.
133 | 
134 | ## Twig Templates
135 | 
136 | Every ``index.html.twig`` file is a Twig template that receives the [BootPress Page Component](https://packagist.org/packages/bootpress/page), so that you can interact with your HTML Page.  The methods available to you are:
137 | 
138 | - ``{{ page.set() }}`` - Set HTML Page properties.  Things like the title, keywords (tags), author, etc.
139 | - ``{{ page.url() }} `` - Either create a url, or manipulate it's query string and fragment.
140 | - ``{{ page.get() }} `` - Access $_GET parameters.
141 | - ``{{ page.post() }}`` - Access $_POST parameters.
142 | - ``{{ page.tag() }} `` - Generate an HTML tag programatically.
143 | - ``{{ page.meta() }} `` - Insert ``<meta>`` tag(s) into the ``<head>`` section of your page.
144 | - ``{{ page.link() }} `` - Include js, css, ico, etc links in your page.
145 | - ``{{ page.style() }} `` - Add CSS ``<style>`` formatting to the ``<head>`` of your page.
146 | - ``{{ page.script() }} `` - Add Java``<script>`` code to the bottom of your page.
147 | - ``{{ page.jquery() }} `` - Put some jQuery into your ``$(document).ready(function(){...})``.
148 | - ``{{ page.id() }} `` - Get a unique id to reference in your CSS or JavaScript.
149 | 
150 | The main one you will use everytime is ``{{ page.set() }}`` like so:
151 | 
152 | ```twig
153 | {{ page.set({
154 |     title: 'A Flowery Post',
155 |     description: 'Aren\'t they beautiful?',
156 |     keywords: 'flowers, nature',
157 |     image: 'flowers.jpg',
158 |     published: 'January 1, 2015'
159 | }) }}
160 | ```
161 | 
162 | The Page properties you can set (and retrieve) are:
163 | 
164 | - '**title**' - The page ``<title>``.
165 | - '**description**' - The meta description of this page.
166 | - '**keywords**' - A comma-separated list of keywords for tagging your blog posts.
167 | - '**robots**' - If set to false then we will not sitemap this page, and the robots will be told to go away.
168 | - '**theme**' - To use a different theme then the one used by default.
169 | - '**image**' - The main image for this page (if any).
170 | - '**author**' - The post author's name.
171 | - '**featured**' - If set to true then it will be displayed before all other posts.  Otherwise known as a "sticky post".
172 | - '**published**' - A date (eg. ``'Jan 1, 2015'``) if this is a post, or ``true`` if it is a page.  If ``false`` (the default) then we consider it unpublished and won't tell anyone.  If a date is in the future then we will wait until then before publishing.
173 | - ... and any other value that you want to set and retrieve later on.  The above just have special meanings to us.
174 | 
175 | To make things even easier, you can put all that information in YAML format within a Twig comment at the top of the page.  For example:
176 | 
177 | ```twig
178 | {#
179 | title: A Flowery Post
180 | description: Aren't they beautiful?
181 | keywords: flowers, nature
182 | image: flowers.jpg
183 | published: January 1, 2015
184 | #}
185 | 
186 | {% markdown %}
187 | 
188 | These are my flowers:
189 | 
190 | <img src="{{ 'flowers.jpg'|asset }}">
191 | 
192 | Aren't they ***beautiful***?
193 | 
194 | {% endmarkdown %}
195 | ```
196 | 
197 | When you check ``if ($file = $blog->page()) { ... }`` we will look for the corresponding Twig template, and if it is there, your **$file** will either be a string if ``$page->url['format'] != 'html'``, or an array suitable for passing to ``$blog->theme->renderTwig($file)`` with the following keys:
198 | 
199 | - '**file**' - The appropriate Twig template that is equipped to deal with these '**type**' of '**vars**'.
200 | - '**type**' - The kind of Blog page you are working with.  Either *'page'*, *'post'*, *'category'*, *'index'*, *'archives'*, *'authors'*, or *'tags'*.
201 | - '**vars**' - For the Twig template to utilize.
202 | - '**default**' => An alternate '**file**' to use if it's missing in your theme.
203 | 
204 | We don't automatically ``$page->send()`` it, so that you can have the opportunity to log or cache the output beforehand.  Now you have your blog info, and you can do anything you want with it.  You can implement a BootPress Blog into any project.  It is as flexible as flexible can be, but if you like the way we do things so far, then let's continue shall we?
205 | 
206 | ## Themes
207 | 
208 | BootPress Themes live in your ``../page/blog/themes/`` folder.  Assuming you have selected the '**default**', when you ``$html = $blog->theme->renderTwig($template)``, it will pass the ``$template['vars']`` to the ``$template['file']`` in the '**../page/blog/themes/default/**' folder, and return your **$html**.  If the ``$template['file']`` does not exist, then a default one will be provided for you.  If at any time you are wondering what ``$template['vars']`` you have to work with, just ``{{ dump() }}`` them, and they will be all spelled out for you.
209 | 
210 | When you ``$blog->theme->layout($html)``, it will pass the **$html** ``{{ content }}`` to your '**../page/blog/themes/default/index.html.twig**' file which could look something like this:
211 | 
212 | ```twig
213 | <!DOCTYPE html>
214 | <html lang="en">
215 | <head>
216 |     <meta charset="utf-8" />
217 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
218 |     <meta name="viewport" content="width=device-width, initial-scale=1" />
219 |     
220 |     <title>{{ page.title }}</title>
221 |     
222 |     <link rel="stylesheet" href="{{ 'css/bootstrap.css'|asset }}">
223 |     <!--[if lte IE 8]><script src="{{ 'js/html5shiv.js'|asset }}"></script><![endif]-->
224 | </head>
225 | <body>
226 | 
227 |     <!-- Content -->
228 |     <div id="content">
229 |         {{ content }}
230 |     </div>
231 | 
232 |     <!-- Sidebar -->
233 |     <div id="sidebar">
234 |         {% include '@theme/sidebar.html.twig' %} 
235 |     </div>
236 | 
237 |     <!-- Scripts -->
238 |     <script src="{{ 'js/jquery.js'|asset }}"></script>
239 |     <script src="{{ 'js/bootstrap.js'|asset }}"></script>
240 | </body>
241 | </html>
242 | ```
243 | 
244 | ## Plugins
245 | 
246 | Plugins are [Twig macros](http://twig.sensiolabs.org/doc/templates.html#macros) that reside in your ``../page/blog/plugins/`` folder, and are easily accessed in any template via ``{% import '@plugin/name' as name %}``.  My recommendation is to follow the packagist naming schema of 'vendor/package' with the main file being 'macro.twig'.  For example, if you put the following at ``../page/blog/plugins/kylob/mailto/macro.twig``:
247 | 
248 | ```twig
249 | {% macro eval(string) %}
250 | 
251 |     {% set js = '' %}
252 |     {% set string = 'document.write(' ~ json_encode(string) ~ ');' %}
253 |     {% for i in range(0, string|length - 1) %}
254 |         {% set js = js ~ '%' ~ bin2hex(string|slice(i, 1)) %}
255 |     {% endfor %}
256 |     <script type="text/javascript">eval(unescape('{{ js }}'))</script>
257 |     
258 | {% endmacro eval %}
259 | ```
260 | 
261 | You could then hide an email address from spam bots like so:
262 | 
263 | ```twig
264 | {% import '@plugin/kylob/mailto/macro.twig' as mailto %}
265 | 
266 | {{ mailto.eval('<a href="mailto:me@example.com">Contact Me</a>') }}
267 | ```
268 | 
269 | Which would result in:
270 | 
271 | ```html
272 | <script type="text/javascript">eval(unescape('%64%6f%63%75%6d%65%6e%74%2e%77%72%69%74%65%28%22%3c%61%20%68%72%65%66%3d%5c%22%6d%61%69%6c%74%6f%3a%6d%65%40%65%78%61%6d%70%6c%65%2e%63%6f%6d%5c%22%3e%43%6f%6e%74%61%63%74%20%4d%65%3c%5c%2f%61%3e%22%29%3b'))</script>
273 | ```
274 | 
275 | You can pass variables among macros in the same namespace (on the same page) by setting ``{{ this(_self, 'key', 'value') }}`` in one macro, and accessing ``{{ this(_self, 'key') }}`` in another.  This allows you to create "properties" so that your macro plugins can behave a little more like "classes".  You can also use nearly every native php function that would be considered safe to use.
276 | 
277 | ## License
278 | 
279 | The MIT License (MIT). Please see [License File](LICENSE.md) for more information.
280 | 
281 | [badge-version]: https://img.shields.io/packagist/v/bootpress/blog.svg?style=flat-square&label=Packagist
282 | [badge-license]: https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square
283 | [badge-hhvm]: https://img.shields.io/badge/HHVM-Tested-8892bf.svg?style=flat-square
284 | [badge-php]: https://img.shields.io/badge/PHP%207-Supported-8892bf.svg?style=flat-square
285 | [badge-travis]: https://img.shields.io/travis/Kylob/Blog/master.svg?style=flat-square
286 | [badge-code-climate]: https://img.shields.io/codeclimate/github/Kylob/Blog.svg?style=flat-square
287 | [badge-coverage]: https://img.shields.io/codeclimate/coverage/github/Kylob/Blog.svg?style=flat-square
288 | 
289 | [link-packagist]: https://packagist.org/packages/bootpress/blog
290 | [link-travis]: https://travis-ci.org/Kylob/Blog
291 | [link-code-climate]: https://codeclimate.com/github/Kylob/Blog
292 | [link-coverage]: https://codeclimate.com/github/Kylob/Blog/coverage
293 | 


--------------------------------------------------------------------------------
/src/Twig/Theme.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace BootPress\Blog\Twig;
  4 | 
  5 | use BootPress\Page\Component as Page;
  6 | use BootPress\Asset\Component as Asset;
  7 | use BootPress\Pagination\Component as Pagination;
  8 | use Symfony\Component\Yaml\Yaml;
  9 | use Symfony\Component\VarDumper\Cloner\VarCloner;
 10 | use Symfony\Component\VarDumper\Dumper\CliDumper;
 11 | use Symfony\Component\VarDumper\Dumper\HtmlDumper;
 12 | use Aptoma\Twig\Extension\MarkdownExtension;
 13 | 
 14 | class Theme
 15 | {
 16 |     /** @var object This self if you don't have ready access to the Blog that called it. */
 17 |     public static $instance;
 18 | 
 19 |     /** @var array Twig template files and the specific vars passed to them. */
 20 |     public static $templates = array();
 21 | 
 22 |     /** @var array Global vars that are available in every Twig template. */
 23 |     public $vars = array();
 24 | 
 25 |     /** @var object A BootPress\Blog\Blog instance. */
 26 |     private $blog;
 27 | 
 28 |     /** @var object A Twig_Environment instance. */
 29 |     private $twig;
 30 | 
 31 |     /** @var array URL info relative to the current Twig template. */
 32 |     private $asset;
 33 | 
 34 |     /** @var array Twig macro namespaced properties. */
 35 |     private $plugin;
 36 | 
 37 |     public function __construct(\BootPress\Blog\Blog $blog)
 38 |     {
 39 |         self::$instance = $this;
 40 |         $this->blog = $blog;
 41 |         $this->vars['blog'] = new \BootPress\Blog\Twig\Object($this->blog->config('blog'), array(
 42 |             'query' => array($this->blog, 'query'),
 43 |         ));
 44 |         $this->vars['page'] = new \BootPress\Blog\Twig\Page();
 45 |         $this->vars['pagination'] = new Pagination();
 46 |     }
 47 | 
 48 |     /**
 49 |      * Get the Twig_Environment instance.  If you call this before we do, then you can customize the ``$options``.
 50 |      * 
 51 |      * @param array $options
 52 |      * 
 53 |      * @return object
 54 |      *
 55 |      * @link http://twig.sensiolabs.org/doc/api.html#environment-options
 56 |      */
 57 |     public function getTwig(array $options = array())
 58 |     {
 59 |         if (is_null($this->twig)) {
 60 |             $page = Page::html();
 61 |             foreach (array('content', 'plugins', 'themes') as $dir) {
 62 |                 if (!is_dir($this->blog->folder.$dir)) {
 63 |                     mkdir($this->blog->folder.$dir, 0755, true);
 64 |                 }
 65 |             }
 66 |             $loader = new \Twig_Loader_Filesystem($page->dir['page'], $page->dir['page']);
 67 |             $loader->addPath($this->blog->folder.'plugins/', 'plugin');
 68 |             $this->twig = new \Twig_Environment($loader, array_merge(array(
 69 |                 'cache' => $this->blog->folder.'cache/twig/',
 70 |                 'auto_reload' => true,
 71 |                 'autoescape' => false,
 72 |             ), $options));
 73 |             $this->twig->addExtension(new MarkdownExtension(new Markdown($this)));
 74 |             $this->twig->addFilter(new \Twig_SimpleFilter('asset', array($this, 'asset')));
 75 |             $this->twig->addFunction(new \Twig_SimpleFunction('dir', array($this, 'dir')));
 76 |             $this->twig->addFunction(new \Twig_SimpleFunction('this', array($this, 'this')));
 77 |             $this->twig->addFunction(new \Twig_SimpleFunction('dump', array($this, 'dump'), array('is_safe' => 'html')));
 78 |             $this->twig->registerUndefinedFunctionCallback(function ($name) {
 79 |                 switch ($name) {
 80 |                     // Array Functions
 81 |                     case 'array_change_key_case': // Changes the case of all keys in an array
 82 |                     case 'array_chunk': // Split an array into chunks
 83 |                     case 'array_column': // Return the values from a single column in the input array
 84 |                     case 'array_combine': // Creates an array by using one array for keys and another for its values
 85 |                     case 'array_count_values': // Counts all the values of an array
 86 |                     case 'array_diff_assoc': // Computes the difference of arrays with additional index check
 87 |                     case 'array_diff_key': // Computes the difference of arrays using keys for comparison
 88 |                     case 'array_diff': // Computes the difference of arrays
 89 |                     case 'array_fill_keys': // Fill an array with values, specifying keys
 90 |                     case 'array_fill': // Fill an array with values
 91 |                     case 'array_filter': // Filters elements of an array using a callback function
 92 |                     case 'array_flip': // Exchanges all keys with their associated values in an array
 93 |                     case 'array_intersect_assoc': // Computes the intersection of arrays with additional index check
 94 |                     case 'array_intersect_key': // Computes the intersection of arrays using keys for comparison
 95 |                     case 'array_intersect': // Computes the intersection of arrays
 96 |                     case 'array_key_exists': // Checks if the given key or index exists in the array
 97 |                     case 'array_keys': // Return all the keys or a subset of the keys of an array
 98 |                     case 'array_map': // Applies the callback to the elements of the given arrays
 99 |                     case 'array_merge_recursive': // Merge two or more arrays recursively
100 |                     case 'array_merge': // Merge one or more arrays
101 |                     case 'array_pad': // Pad array to the specified length with a value
102 |                     case 'array_product': // Calculate the product of values in an array
103 |                     case 'array_rand': // Pick one or more random entries out of an array
104 |                     case 'array_replace_recursive': // Replaces elements from passed arrays into the first array recursively
105 |                     case 'array_replace': // Replaces elements from passed arrays into the first array
106 |                     case 'array_reverse': // Return an array with elements in reverse order
107 |                     case 'array_search': // Searches the array for a given value and returns the first corresponding key if successful
108 |                     case 'array_slice': // Extract a slice of the array
109 |                     case 'array_sum': // Calculate the sum of values in an array
110 |                     case 'array_unique': // Removes duplicate values from an array
111 |                     case 'array_values': // Return all the values of an array
112 |                     case 'count': // Count all elements in an array, or something in an object
113 |                     case 'in_array': // Checks if a value exists in an array
114 | 
115 |                     // Date/Time Functions
116 |                     case 'date_parse': // Returns associative array with detailed info about given date
117 |                     case 'date_sun_info': // Returns an array with information about sunset/sunrise and twilight begin/end
118 |                     case 'getdate': // Get date/time information
119 |                     case 'gettimeofday': // Get current time
120 |                     case 'gmdate': // Format a GMT/UTC date/time
121 |                     case 'gmmktime': // Get Unix timestamp for a GMT date
122 |                     case 'microtime': // Return current Unix timestamp with microseconds
123 |                     case 'mktime': // Get Unix timestamp for a date
124 |                     case 'strtotime': // Parse about any English textual datetime description into a Unix timestamp
125 |                     case 'time': // Return current Unix timestamp
126 | 
127 |                     // JSON Functions
128 |                     case 'json_decode': // Decodes a JSON string
129 |                     case 'json_encode': // Returns the JSON representation of a value
130 | 
131 |                     // Mail Functions
132 |                     case 'mail': // Send mail
133 | 
134 |                     // Math Functions
135 |                     case 'abs': // Absolute value
136 |                     case 'acos': // Arc cosine
137 |                     case 'acosh': // Inverse hyperbolic cosine
138 |                     case 'asin': // Arc sine
139 |                     case 'asinh': // Inverse hyperbolic sine
140 |                     case 'atan2': // Arc tangent of two variables
141 |                     case 'atan': // Arc tangent
142 |                     case 'atanh': // Inverse hyperbolic tangent
143 |                     case 'base_convert': // Convert a number between arbitrary bases
144 |                     case 'bindec': // Binary to decimal
145 |                     case 'ceil': // Round fractions up
146 |                     case 'cos': // Cosine
147 |                     case 'cosh': // Hyperbolic cosine
148 |                     case 'decbin': // Decimal to binary
149 |                     case 'dechex': // Decimal to hexadecimal
150 |                     case 'decoct': // Decimal to octal
151 |                     case 'deg2rad': // Converts the number in degrees to the radian equivalent
152 |                     case 'exp': // Calculates the exponent of e
153 |                     case 'expm1': // Returns exp(number) - 1, computed in a way that is accurate even when the value of number is close to zero
154 |                     case 'floor': // Round fractions down
155 |                     case 'fmod': // Returns the floating point remainder (modulo) of the division of the arguments
156 |                     case 'getrandmax': // Show largest possible random value
157 |                     case 'hexdec': // Hexadecimal to decimal
158 |                     case 'hypot': // Calculate the length of the hypotenuse of a right-angle triangle
159 |                     case 'is_finite': // Finds whether a value is a legal finite number
160 |                     case 'is_infinite': // Finds whether a value is infinite
161 |                     case 'is_nan': // Finds whether a value is not a number
162 |                     case 'lcg_value': // Combined linear congruential generator
163 |                     case 'log10': // Base-10 logarithm
164 |                     case 'log1p': // Returns log(1 + number), computed in a way that is accurate even when the value of number is close to zero
165 |                     case 'log': // Natural logarithm
166 |                     case 'mt_getrandmax': // Show largest possible random value
167 |                     case 'mt_rand': // Generate a better random value
168 |                     case 'mt_srand': // Seed the better random number generator
169 |                     case 'octdec': // Octal to decimal
170 |                     case 'pi': // Get value of pi
171 |                     case 'pow': // Exponential expression
172 |                     case 'rad2deg': // Converts the radian number to the equivalent number in degrees
173 |                     case 'rand': // Generate a random integer
174 |                     case 'round': // Rounds a float
175 |                     case 'sin': // Sine
176 |                     case 'sinh': // Hyperbolic sine
177 |                     case 'sqrt': // Square root
178 |                     case 'srand': // Seed the random number generator
179 |                     case 'tan': // Tangent
180 |                     case 'tanh': // Hyperbolic tangent
181 | 
182 |                     // Misc Functions
183 |                     case 'pack': //  Pack data into binary string
184 |                     case 'unpack': // Unpack data from binary string
185 | 
186 |                     // Multibyte String Functions
187 |                     case 'mb_convert_case': // Perform case folding on a string
188 |                     case 'mb_convert_encoding': // Convert character encoding
189 |                     case 'mb_strimwidth': // Get truncated string with specified width
190 |                     case 'mb_stripos': // Finds position of first occurrence of a string within another, case insensitive
191 |                     case 'mb_stristr': // Finds first occurrence of a string within another, case insensitive
192 |                     case 'mb_strlen': // Get string length
193 |                     case 'mb_strpos': // Find position of first occurrence of string in a string
194 |                     case 'mb_strrchr': // Finds the last occurrence of a character in a string within another
195 |                     case 'mb_strrichr': // Finds the last occurrence of a character in a string within another, case insensitive
196 |                     case 'mb_strripos': // Finds position of last occurrence of a string within another, case insensitive
197 |                     case 'mb_strrpos': // Find position of last occurrence of a string in a string
198 |                     case 'mb_strstr': // Finds first occurrence of a string within another
199 |                     case 'mb_strtolower': // Make a string lowercase
200 |                     case 'mb_strtoupper': // Make a string uppercase
201 |                     case 'mb_strwidth': // Return width of string
202 |                     case 'mb_substr_count': // Count the number of substring occurrences
203 |                     case 'mb_substr': // Get part of string
204 | 
205 |                     // String Functions
206 |                     case 'addcslashes': // Quote string with slashes in a C style
207 |                     case 'addslashes': // Quote string with slashes
208 |                     case 'bin2hex': // Convert binary data into hexadecimal representation
209 |                     case 'chr': // Return a specific character - complements ord()
210 |                     case 'chunk_split': // Split a string into smaller chunks
211 |                     case 'explode': // Split a string by string
212 |                     case 'hex2bin': // Decodes a hexadecimally encoded binary string
213 |                     case 'htmlspecialchars': // Convert special characters to HTML entities
214 |                     case 'implode': // Join array elements with a string
215 |                     case 'lcfirst': // Make a string's first character lowercase
216 |                     case 'ltrim': // Strip whitespace (or other characters) from the beginning of a string
217 |                     case 'nl2br': // Inserts HTML line breaks before all newlines in a string
218 |                     case 'number_format': // Format a number with grouped thousands
219 |                     case 'ord': // Return ASCII value of character - complements chr()
220 |                     case 'rtrim': // Strip whitespace (or other characters) from the end of a string
221 |                     case 'str_ireplace': // Case-insensitive version of str_replace()
222 |                     case 'str_pad': // Pad a string to a certain length with another string
223 |                     case 'str_repeat': // Repeat a string
224 |                     case 'str_replace': // Replace all occurrences of the search string with the replacement string
225 |                     case 'str_rot13': // Perform the rot13 transform on a string
226 |                     case 'str_shuffle': // Randomly shuffles a string
227 |                     case 'str_split': // Convert a string to an array
228 |                     case 'str_word_count': // Return information about words used in a string
229 |                     case 'strip_tags': // Strip HTML and PHP tags from a string
230 |                     case 'stripos': // Find the position of the first occurrence of a case-insensitive substring in a string
231 |                     case 'stristr': // Case-insensitive strstr()
232 |                     case 'strlen': // Get string length
233 |                     case 'strpos': // Find the position of the first occurrence of a substring in a string
234 |                     case 'strrchr': // Find the last occurrence of a character in a string
235 |                     case 'strrev': // Reverse a string
236 |                     case 'strripos': // Find the position of the last occurrence of a case-insensitive substring in a string
237 |                     case 'strrpos': // Find the position of the last occurrence of a substring in a string
238 |                     case 'strstr': // Find the first occurrence of a string
239 |                     case 'strtok': // Tokenize string
240 |                     case 'strtolower': // Make a string lowercase
241 |                     case 'strtoupper': // Make a string uppercase
242 |                     case 'strtr': // Translate characters or replace substrings
243 |                     case 'substr_count': // Count the number of substring occurrences
244 |                     case 'substr': // Return part of a string
245 |                     case 'trim': // Strip whitespace (or other characters) from the beginning and end of a string
246 |                     case 'ucfirst': // Make a string's first character uppercase
247 |                     case 'ucwords': // Uppercase the first character of each word in a string
248 |                     case 'wordwrap': // Wraps a string to a given number of characters
249 | 
250 |                     // Variable handling Functions
251 |                     case 'gettype': // Get the type of a variable
252 |                     case 'is_array': // Finds whether a variable is an array
253 |                     case 'is_bool': // Finds out whether a variable is a boolean
254 |                     case 'is_float': // Finds whether the type of a variable is float
255 |                     case 'is_int': // Find whether the type of a variable is integer
256 |                     case 'is_null': // Finds whether a variable is NULL
257 |                     case 'is_numeric': // Finds whether a variable is a number or a numeric string
258 |                     case 'is_string': // Find whether the type of a variable is string
259 |                     case 'serialize': // Generates a storable representation of a value
260 |                     case 'unserialize': // Creates a PHP value from a stored representation
261 |                         return new \Twig_SimpleFunction($name, $name);
262 |                         break;
263 | 
264 |                     // Return by reference, so we return directly
265 |                     case 'array_pop': // Pop the element off the end of array
266 |                     case 'array_shift': // Shift an element off the beginning of array
267 |                     case 'array_splice': // Remove a portion of the array and replace it with something else
268 |                     case 'arsort': // Sort an array in reverse order and maintain index association
269 |                     case 'asort': // Sort an array and maintain index association
270 |                     case 'krsort': // Sort an array by key in reverse order
271 |                     case 'ksort': // Sort an array by key
272 |                     case 'natcasesort': // Sort an array using a case insensitive "natural order" algorithm
273 |                     case 'natsort': // Sort an array using a "natural order" algorithm
274 |                     case 'rsort': // Sort an array in reverse order
275 |                     case 'shuffle': // Shuffle an array
276 |                     case 'sort': // Sort an array
277 |                     case 'settype': // Set the type of a variable
278 |                         return new \Twig_SimpleFunction($name, function () use ($name) {
279 |                             $args = func_get_args();
280 |                             $reference = array_shift($args);
281 |                             switch (count($args)) {
282 |                                 case 0: $name($reference); break;
283 |                                 case 1: $name($reference, array_shift($args)); break;
284 |                                 case 2: $name($reference, array_shift($args), array_shift($args)); break;
285 |                                 default: $name($reference, array_shift($args), array_shift($args), array_shift($args)); break;
286 |                             }
287 | 
288 |                             return $reference;
289 |                         });
290 |                         break;
291 | 
292 |                     // PCRE Functions
293 |                     case 'preg_filter': // Perform a regular expression search and replace - 4
294 |                     case 'preg_grep': // Return array entries that match the pattern
295 |                     case 'preg_match_all': // Perform a global regular expression match
296 |                     case 'preg_match': // Perform a regular expression match
297 |                     case 'preg_quote': // Quote regular expression characters
298 |                     case 'preg_replace': // Perform a regular expression search and replace - 4
299 |                     case 'preg_split': // Split string by a regular expression - 3
300 |                         return new \Twig_SimpleFunction($name, function () use ($name) {
301 |                             $args = func_get_args();
302 |                             $pattern = array_shift($args);
303 |                             if ($name != 'preg_quote') {
304 |                                 $this->removeEval($pattern);
305 |                             }
306 |                             if (strpos($name, 'match')) {
307 |                                 $name($pattern, array_shift($args), $matches);
308 | 
309 |                                 return $matches;
310 |                             } else {
311 |                                 array_unshift($args, $pattern);
312 | 
313 |                                 return call_user_func_array($name, $args);
314 |                             }
315 |                         });
316 |                         break;
317 |                 }
318 | 
319 |                 return false;
320 |             });
321 |         }
322 | 
323 |         return $this->twig;
324 |     }
325 | 
326 |     /**
327 |      * Render a Twig template.
328 |      *
329 |      * @param string|array $file The template file.
330 |      * @param array        $vars To pass to the Twig template.
331 |      *
332 |      * @return string
333 |      *
334 |      * @throws LogicException If the **$file** is not in the ``$page->dir()``, or if it doesn't exist.
335 |      */
336 |     public function renderTwig($file, array $vars = array())
337 |     {
338 |         $page = Page::html();
339 |         if (is_array($file)) {
340 |             $vars = (isset($file['vars']) && is_array($file['vars'])) ? $file['vars'] : array();
341 |             $default = (isset($file['default']) && is_dir($file['default'])) ? rtrim($file['default'], '/').'/' : null;
342 |             $file = (isset($file['file']) && is_string($file['file'])) ? $file['file'] : '';
343 |             if ($default && $template = $this->getFiles($file, $default)) {
344 |                 $file = array_pop($template);
345 |             }
346 |         }
347 |         $base = $page->dir['page'];
348 |         $cut = strlen($base);
349 |         if (strpos($file, $this->blog->folder.'themes/') === 0) {
350 |             $dir = $this->blog->folder.'themes/';
351 |             $file = substr($file, strlen($dir));
352 |             $theme = strstr($file, '/', true).'/';
353 |             $dir .= $theme;
354 |             $file = substr($file, strlen($theme));
355 |             $loader = $this->getTwig()->getLoader();
356 |             $loader->addPath($dir, 'theme');
357 |             $dir = substr($dir, $cut);
358 |         } elseif (strpos($file, $base) === 0) {
359 |             $dir = substr(dirname($file).'/', $cut);
360 |             $file = basename($file);
361 |         } else {
362 |             throw new \LogicException("The '{$file}' is not in your website's Page::dir folder.");
363 |         }
364 |         if (!is_file($base.$dir.$file)) {
365 |             throw new \LogicException("The '{$dir}{$file}' file does not exist.");
366 |         }
367 |         if (is_null($this->asset)) { // our first time here
368 |             $this->getTwig()->setParser(new Parser($this->getTwig()));
369 |         }
370 |         $this->asset = array(
371 |             'dir' => $dir,
372 |             'chars' => $page->url['chars'],
373 |         );
374 |         $save = array(
375 |             'template' => $dir.$file,
376 |             'vars' => $vars,
377 |             'start' => microtime(true),
378 |         );
379 |         try {
380 |             $html = $this->getTwig()->render($dir.$file, array_merge($vars, $this->vars));
381 |             $save['output'] = $html;
382 |         } catch (\Exception $e) {
383 |             $html = '<p>'.$e->getMessage().'</p>';
384 |             $save['error'] = $e->getMessage();
385 |         }
386 |         $save['end'] = microtime(true);
387 |         $save['time'] = $save['end'] - $save['start'];
388 |         self::$templates[] = $save;
389 | 
390 |         return $html;
391 |     }
392 | 
393 |     /**
394 |      * Returns an HTML string from your Markdown **$content**, and allows you to set your preferred Markdown provider.
395 |      * 
396 |      * @param string|callable $content
397 |      * 
398 |      * @return string|null
399 |      *
400 |      * @example
401 |      *
402 |      * ```twig
403 |      * <div>
404 |      *     <h1 class="someClass">{{ page.title }}</h1>
405 |      * 
406 |      *     {% markdown %}
407 |      *     This is a list that is indented to match the context around the markdown tag:
408 |      * 
409 |      *     * List item 1
410 |      *     * List item 2
411 |      *         * Sub List Item
412 |      *             * Sub Sub List Item
413 |      * 
414 |      *     The following block will be transformed as code, as it is indented more than the
415 |      *     surrounding content:
416 |      * 
417 |      *         $code = "good";
418 |      * 
419 |      *     {% endmarkdown %}
420 |      * 
421 |      * </div>
422 |      * ```
423 |      */
424 |     public function markdown($content)
425 |     {
426 |         static $markdown = null;
427 |         if (is_callable($content)) {
428 |             $markdown = $content;
429 |         } elseif (is_null($markdown)) {
430 |             $parsedown = new \ParsedownExtra();
431 |             $markdown = function ($content) use ($parsedown) {
432 |                 return $parsedown->text($content);
433 |             };
434 |         }
435 | 
436 |         return (is_string($content)) ? $markdown($content) : null;
437 |     }
438 | 
439 |     /**
440 |      * Prepends a url to **$path**, relative to the main index.html.twig being fetched.
441 |      *
442 |      * @param string|array $path An asset string eg. image.jpg
443 |      * @param object       $twig ``_self`` if the **$path** is relative to the current template.  This is useful for plugin macros and child themes.
444 |      *
445 |      * @return string|array Whatever the **$path** was.  If the **$path**'s string is not a relative asset, then it is just returned as is.  If the **$path** is an array, then every key and value in it will be turned into a url if it is a relative asset, and the rest of the array will remain the same.
446 |      *
447 |      * @example
448 |      *
449 |      * ```twig
450 |      * <img src="{{ 'image.jpg'|asset }}">
451 |      * ```
452 |      */
453 |     public function asset($path, \Twig_Template $twig = null)
454 |     {
455 |         if (is_string($path)) {
456 |             if ($this->asset && preg_match('/^'.implode('', array(
457 |                 '(?!((f|ht)tps?:)?\/\/)',
458 |                 '['.$this->asset['chars'].'.\/]+',
459 |                 '\.('.Asset::PREG_TYPES.')',
460 |                 '.*',
461 |             )).'$/i', ltrim($path), $matches)) {
462 |                 $page = Page::html();
463 |                 $dir = ($twig) ? $this->dir($twig, $matches[0]) : \phpUri::parse($this->asset['dir'])->join($matches[0]);
464 |                 $asset = $page->url('page', $dir);
465 |             }
466 |         } elseif ($this->asset && is_array($path)) {
467 |             $asset = array();
468 |             foreach ($path as $key => $value) {
469 |                 $asset[$this->asset($key, $twig)] = $this->asset($value, $twig);
470 |             }
471 |         }
472 | 
473 |         return (isset($asset)) ? $asset : $path;
474 |     }
475 | 
476 |     /**
477 |      * Get an absolute **$path** relative to the **$twig** template.
478 |      * 
479 |      * @param object $twig ``_self`` so we know who you are.
480 |      * @param mixed  $path Relative to current folder.
481 |      * 
482 |      * @return string An absolute file **$path**.
483 |      *
484 |      * @example
485 |      *
486 |      * ```twig
487 |      * {% include dir(_self, '../file.html.twig') %}
488 |      * ```
489 |      */
490 |     public function dir(\Twig_Template $twig, $path = '')
491 |     {
492 |         return \phpUri::parse(str_replace('\\', '/', dirname($this->getTwig()->getLoader()->getCacheKey($twig->getTemplateName()))).'/')->join($path);
493 |     }
494 | 
495 |     /**
496 |      * A reference to the current template, sort of.  This enables your plugin macros to behave more like a class, and these are your properties.
497 |      * 
498 |      * @param object $twig  ``_self`` so we know who you are.
499 |      * @param mixed  $key   What you want to either set or retrieve.  Pass ``null`` to remove them all.  Make it an array to set multiple values at once.
500 |      * @param mixed  $value Of the **$key** if you are setting it.  Pass ``null`` to remove only this one.
501 |      * 
502 |      * @return mixed If you don't specify **$key** or **$value**, then all of the "properties" (an array) will be returned.  If you don't include a **$value**, then the **$key** will be returned if it exists.  Otherwise you get ``null``.
503 |      *
504 |      * @example
505 |      *
506 |      * ```twig
507 |      * {{ this(_self, 'key', 'value') }}
508 |      * ```
509 |      */
510 |     public function this(\Twig_Template $twig, $key = null, $value = null)
511 |     {
512 |         $name = $twig->getTemplateName();
513 |         if (!isset($this->plugin[$name])) {
514 |             $this->plugin[$name] = array();
515 |         }
516 |         if (func_num_args() == 1) {
517 |             return $this->plugin[$name]; // return all values
518 |         } elseif (is_null($key)) {
519 |             $this->plugin[$name] = array(); // remove all values
520 |         } elseif (is_array($key)) {
521 |             $this->plugin[$name] = $key + $this->plugin[$name]; // set multiple values
522 |         } elseif (func_num_args() == 3) {
523 |             if (is_null($value)) {
524 |                 unset($this->plugin[$name][$key]); // remove a single value
525 |             } else {
526 |                 $this->plugin[$name][$key] = $value; // set a single value
527 |             }
528 |         } elseif (isset($this->plugin[$name][$key])) {
529 |             return $this->plugin[$name][$key]; // return a single value
530 |         }
531 |     }
532 | 
533 |     /**
534 |      * Dumps a beautifully formatted debug string of your **$var**.
535 |      * 
536 |      * @param mixed $var If you don't have one, then we will pass the current template name and vars that we initially gave you.  Objects will only be named, and not displayed.
537 |      * 
538 |      * @return string
539 |      *
540 |      * @example
541 |      *
542 |      * ```twig
543 |      * {{ dump() }}
544 |      * ```
545 |      */
546 |     public function dump($var = null)
547 |     {
548 |         if (func_num_args() == 0) {
549 |             $var = array_slice(self::$templates, -1);
550 |             $var = array_shift($var);
551 |             $var = array('global' => $this->vars, 'vars' => $var['vars']);
552 |         }
553 | 
554 |         return self::dumper($var, array('dumper' => 'html'));
555 |     }
556 | 
557 |     /**
558 |      * Creates a layout using the ``$page->theme`` you have specified.
559 |      *
560 |      * @param string $html The main content of your page.
561 |      *
562 |      * @return string
563 |      */
564 |     public function layout($html)
565 |     {
566 |         $page = Page::html();
567 |         $theme = $page->theme;
568 |         if ($theme === false) {
569 |             return $html;
570 |         } elseif (is_callable($theme)) {
571 |             return $theme($html, $this->vars);
572 |         } elseif (is_file($theme)) {
573 |             return $page->load($theme, array(
574 |                 'content' => $html,
575 |                 'vars' => $this->vars,
576 |             ));
577 |         } elseif (!$index = $this->getFiles('index.html.twig', __DIR__.'/theme/')) {
578 |             return $html;
579 |         }
580 |         $vars = array(
581 |             'content' => $html,
582 |             'config' => array(),
583 |         );
584 |         if ($config = $this->getFiles('config.yml')) {
585 |             foreach ($config as $file) { // any child values will override the parents
586 |                 $vars['config'] = array_merge($vars['config'], (array) Yaml::parse(file_get_contents($file)));
587 |             }
588 |         }
589 | 
590 |         return $this->renderTwig(array_pop($index), $vars);
591 |     }
592 | 
593 |     public static function dumper($var, array $options = array())
594 |     {
595 |         extract(array_merge(array(
596 |             'dumper' => ('cli' === PHP_SAPI) ? 'cli' : 'html',
597 |             'items' => 100,
598 |             'string' => 100,
599 |             'indent' => '    ',
600 |         ), $options));
601 |         $output = '';
602 |         $cloner = new VarCloner();
603 |         $cloner->setMaxItems($items);
604 |         $cloner->setMaxString($string);
605 |         $dumper = ($dumper == 'cli') ? new CliDumper() : new HtmlDumper();
606 |         $dumper->dump($cloner->cloneVar(self::wringer($var)), function ($line, $depth) use (&$output, $indent) {
607 |             $output .= ($depth >= 0) ? str_repeat($indent, $depth).$line."\n" : '';
608 |         });
609 | 
610 |         return trim($output);
611 |     }
612 | 
613 |     /**
614 |      * Returns **$data** suitable for displaying.
615 |      * 
616 |      * @param mixed $data
617 |      * 
618 |      * @return mixed
619 |      *
620 |      * @used-by dumper
621 |      */
622 |     private static function wringer($data)
623 |     {
624 |         if (is_object($data)) {
625 |             if ($data instanceof \BootPress\Blog\Twig\Object) {
626 |                 $data = $data->properties + $data->methods;
627 |             } elseif ($data instanceof \BootPress\Blog\Twig\Page) {
628 |                 $data = $data->html + $data->methods;
629 |             } else {
630 |                 $data = get_class($data).' Object';
631 |             }
632 |         }
633 |         if (is_array($data)) {
634 |             $cloner = array();
635 |             foreach ($data as $key => $value) {
636 |                 $cloner[$key] = self::wringer($value);
637 |             }
638 | 
639 |             return $cloner;
640 |         }
641 |         if (is_string($data)) {
642 |             $data = str_replace(array("\r", "\n", "\t"), array('\\r', '\\n', '\\t'), $data);
643 |         }
644 | 
645 |         return $data;
646 |     }
647 | 
648 |     /**
649 |      * Gets all the file **$name**'s within the selected theme.
650 |      *
651 |      * @param string $name    The file you are looking for eg. 'index.html.twig'
652 |      * @param string $default The file path to a default template if no other is available.  It will be copied to the theme folder's root.  Must include a trailing slash.
653 |      *
654 |      * @return array|null
655 |      */
656 |     private function getFiles($name, $default = null)
657 |     {
658 |         $files = array();
659 |         if (!empty($name)) {
660 |             $page = Page::html();
661 |             $themes = $page->dir($this->blog->folder, 'themes');
662 |             if (!empty($page->theme) && is_string($page->theme) && is_dir($themes.$page->theme)) {
663 |                 $path = str_replace('\\', '/', $page->theme);
664 |             } else {
665 |                 $path = $this->blog->config('blog', 'theme');
666 |             }
667 |             $paths = array_filter(explode('/', preg_replace('/[^a-z0-9-\/]/', '', $path)));
668 |             if (!empty($paths)) {
669 |                 $previous = '';
670 |                 foreach ($paths as $level => $dir) {
671 |                     $previous .= $dir.'/';
672 |                     if (is_file($themes.$previous.$name)) {
673 |                         $files[$level] = $themes.$previous.$name;
674 |                     }
675 |                 }
676 |                 if (empty($files) && !empty($default) && is_file($default.$name)) {
677 |                     $root = array_shift($paths);
678 |                     if (!is_dir($themes.$root)) {
679 |                         mkdir($themes.$root, 0755, true);
680 |                     }
681 |                     $files[] = $page->file($themes, $root, $name);
682 |                     copy($default.$name, $files[0]);
683 |                 }
684 |             }
685 |         }
686 | 
687 |         return (!empty($files)) ? $files : null;
688 |     }
689 | 
690 |     /**
691 |      * Remove 'e' eval modifier from pattern.
692 |      * 
693 |      * @param mixed $pattern Regex backslashes must be double-escaped to work properly ie. '//'
694 |      * 
695 |      * @return mixed
696 |      *
697 |      * @link http://php.net/manual/en/reference.pcre.pattern.modifiers.php#reference.pcre.pattern.modifiers.eval
698 |      * @link http://twig.sensiolabs.org/doc/templates.html#comparisons
699 |      */
700 |     private function removeEval(&$pattern)
701 |     {
702 |         if (is_array($pattern)) {
703 |             foreach ($pattern as $key => $value) {
704 |                 $pattern[$key] = $this->removeEval($value);
705 |             }
706 |         } elseif (is_string($pattern)) {
707 |             $pattern = trim($pattern);
708 |             $mods = strrpos($pattern, substr($pattern, 0, 1));
709 |             $pattern = substr($pattern, 0, $mods).str_replace('e', '', substr($pattern, $mods));
710 |         }
711 | 
712 |         return $pattern;
713 |     }
714 | }
715 | 


--------------------------------------------------------------------------------
/src/Blog.php:
--------------------------------------------------------------------------------
   1 | <?php
   2 | 
   3 | namespace BootPress\Blog;
   4 | 
   5 | use BootPress\Page\Component as Page;
   6 | use BootPress\SQLite\Component as SQLite;
   7 | use BootPress\Sitemap\Component as Sitemap;
   8 | use BootPress\Hierarchy\Component as Hierarchy;
   9 | use BootPress\Pagination\Component as Pagination;
  10 | use Symfony\Component\Finder\Finder;
  11 | use Symfony\Component\Yaml\Yaml;
  12 | use Spartz\TextFormatter\TextFormatter;
  13 | use URLify;
  14 | 
  15 | class Blog
  16 | {
  17 |     /** @var string The current version. */
  18 |     const VERSION = '1.3';
  19 | 
  20 |     /** @var object The Blog's BootPress\SQLite\Component Database. */
  21 |     protected $db;
  22 | 
  23 |     /** @var object A BootPress\Blog\Twig\Theme instance for creating layouts, and fetching Twig templates. */
  24 |     protected $theme;
  25 | 
  26 |     /** @var string Where the Blog directory resides. */
  27 |     protected $folder;
  28 | 
  29 |     /** @var array All of the Blog's saved config values. */
  30 |     private $config;
  31 | 
  32 |     /** @var array Saved id's so we don't have to look them up twice. */
  33 |     private $ids;
  34 | 
  35 |     /**
  36 |      * Magic getter for the '**db**', '**theme**', and '**folder**' protected properties.
  37 |      * 
  38 |      * @param string $name
  39 |      * 
  40 |      * @return null|string
  41 |      */
  42 |     public function __get($name)
  43 |     {
  44 |         switch ($name) {
  45 |             case 'db':
  46 |             case 'theme':
  47 |             case 'folder':
  48 |                 return $this->$name;
  49 |                 break;
  50 |             default:
  51 |                 return $this->db->settings($name);
  52 |                 break;
  53 |         }
  54 |     }
  55 | 
  56 |     /**
  57 |      * Get the Blog all set up and ready to go.
  58 |      * 
  59 |      * @param string $folder Where you want the blog to go, relative to ``$page->dir()``.
  60 |      *
  61 |      * ```php
  62 |      * $blog = new \BootPress\Blog\Component();
  63 |      * ```
  64 |      */
  65 |     public function __construct($folder = 'blog')
  66 |     {
  67 |         $page = Page::html();
  68 | 
  69 |         // $this->folder
  70 |         $this->folder = $page->dir($folder);
  71 |         if (!is_dir($this->folder.'content')) {
  72 |             mkdir($this->folder.'content', 0755, true);
  73 |         }
  74 | 
  75 |         // set 'blog/listings' and 'blog/config' url's
  76 |         $blog = $page->url['base'];
  77 |         $listings = $this->config('blog', 'listings');
  78 |         $page->url('set', 'blog/listings', ($listings ? $blog.$listings.'/' : $blog));
  79 |         $page->url('set', 'blog/config', $blog.'page/'.substr($this->folder, strlen($page->dir['page'])));
  80 | 
  81 |         // $this->theme
  82 |         $this->theme = new Twig\Theme($this);
  83 | 
  84 |         // $this->db
  85 |         $this->db = new SQLite($this->folder.'Blog.db');
  86 |         if ($this->db->created || version_compare(self::VERSION, $this->db->settings('version'), '>')) {
  87 |             $this->db->settings('version', self::VERSION);
  88 |             $this->db->create('blog', array(
  89 |                 'id' => 'INTEGER PRIMARY KEY',
  90 |                 'page' => 'TEXT NOT NULL DEFAULT "'.serialize(array()).'"',
  91 |                 'path' => 'TEXT UNIQUE COLLATE NOCASE',
  92 |                 'title' => 'TEXT NOT NULL DEFAULT ""',
  93 |                 'featured' => 'INTEGER NOT NULL DEFAULT 0',
  94 |                 'published' => 'INTEGER NOT NULL DEFAULT 0',
  95 |                 'updated' => 'INTEGER NOT NULL DEFAULT 0',
  96 |                 'author_id' => 'INTEGER NOT NULL DEFAULT 0',
  97 |                 'category_id' => 'INTEGER NOT NULL DEFAULT 0',
  98 |                 'search' => 'INTEGER NOT NULL DEFAULT 1',
  99 |                 'content' => 'TEXT NOT NULL DEFAULT ""',
 100 |             ), array('featured, published, updated, author_id', 'category_id'));
 101 |             $this->db->create('authors', array(
 102 |                 'id' => 'INTEGER PRIMARY KEY',
 103 |                 'path' => 'TEXT UNIQUE COLLATE NOCASE',
 104 |                 'name' => 'TEXT NOT NULL COLLATE NOCASE DEFAULT ""',
 105 |             ));
 106 |             $this->db->create('categories', array(
 107 |                 'id' => 'INTEGER PRIMARY KEY',
 108 |                 'path' => 'TEXT UNIQUE COLLATE NOCASE',
 109 |                 'name' => 'TEXT NOT NULL COLLATE NOCASE DEFAULT ""',
 110 |                 'parent' => 'INTEGER NOT NULL DEFAULT 0',
 111 |                 'level' => 'INTEGER NOT NULL DEFAULT 0',
 112 |                 'lft' => 'INTEGER NOT NULL DEFAULT 0',
 113 |                 'rgt' => 'INTEGER NOT NULL DEFAULT 0',
 114 |             ));
 115 |             $this->db->create('tags', array(
 116 |                 'id' => 'INTEGER PRIMARY KEY',
 117 |                 'path' => 'TEXT UNIQUE COLLATE NOCASE',
 118 |                 'name' => 'TEXT NOT NULL COLLATE NOCASE DEFAULT ""',
 119 |             ));
 120 |             $this->db->create('tagged', array(
 121 |                 'blog_id' => 'INTEGER NOT NULL DEFAULT 0',
 122 |                 'tag_id' => 'INTEGER NOT NULL DEFAULT 0',
 123 |             ), array('unique' => 'blog_id, tag_id'));
 124 |             if ($this->db->created) {
 125 |                 $this->updateDatabase();
 126 |             }
 127 |         }
 128 |         if (($next = $this->db->settings('future_post')) && $next < time()) {
 129 |             $this->db->exec(array(
 130 |                 'UPDATE blog SET published = published * -1',
 131 |                 'WHERE featured <= 0 AND published > 1 AND published < ?',
 132 |             ), time());
 133 |             $this->db->settings('future_post', $this->db->value(array(
 134 |                 'SELECT published FROM blog',
 135 |                 'WHERE featured <= 0 AND published > 1',
 136 |                 'ORDER BY published ASC LIMIT 1',
 137 |             )));
 138 |         }
 139 |     }
 140 | 
 141 |     /**
 142 |      * Executes common queries on the Blog database.  You can use this in your Twig templates via ``{{ blog.query() }}``.
 143 |      *
 144 |      * If ``$type`` is:
 145 |      * 
 146 |      * - An ``array()`` - We will return an array of listings (ie. Blog posts or "The Loop") **IF** ``$params`` is a BootPress\Pagination\Component object (so we can know how many you want at a time), otherwise this will return the total number of listings.  If your array has one of the following keys, then it will only return the applicable listing's array (posts) or integer (count).
 147 |      *   - '**archives**' => An ``array($from, $to)`` of UNIX timestamps.
 148 |      *   - '**authors**' => An authors path (url) string eg. 'joe-bloggs'.
 149 |      *   - '**tags**' => A tag path (url) string eg. 'tagged'.
 150 |      *   - '**categories**' => A category path (url) string eg. 'category/subcategory'.
 151 |      *   - '**search**' => A search term eg. 'search'.  This does not apply to 'archives', 'authors', or 'tags'.
 152 |      *     - You "Loop" will also now contain a '**snippet**' string, and '**words**' array so that you can show the relevancy of your results.
 153 |      *     - If you really want to get fancy, then include a ``$type['weights']`` array of numbers to give more or less "weight" to the following (in order now): 'path', 'title', 'description', 'keywords', and 'content'.  The default weights are ``array(1,1,1,1,1)``, every field being of equal importance.
 154 |      *   - If by chance you already have the total count and want to save yourself a heap of time, you can include ``$type['count']`` with a total to help us out.
 155 |      *
 156 |      * ```twig
 157 |      * {% if not pagination.set('page', 10) %}
 158 |      *     {{ pagination.total(blog.query([], 'count')) }}
 159 |      * {% endif %}
 160 |      * 
 161 |      * {% set posts = blog.query([], pagination) %}
 162 |      *
 163 |      * {{ dump(posts) }}
 164 |      * ```
 165 |      *
 166 |      * - '**similar**' - Returns an array of similarly tagged listings for the current, comma-separated ``$page->keywords`` string.  Ordered by rank.
 167 |      *   - (required) Set ``$params`` to the maximum number you want to return.
 168 |      *   - To specify the keywords, then set the $params to an ``array(3, 'custom, tags')`` for example.
 169 |      *
 170 |      * ```twig
 171 |      * {{ dump(blog.query('similar', 3)) }}
 172 |      * ```
 173 |      *
 174 |      * - '**featured**' - Returns an array of featured blog posts.  Ordered by published date descending.
 175 |      *   - (optional) Set ``$params`` to the maximum number you want to return.
 176 |      *
 177 |      * ```twig
 178 |      * {{ dump(blog.query('featured')) }}
 179 |      * ```
 180 |      *
 181 |      * - '**recent**' - Returns an array of recent blog posts, and excludes any featured posts.  Ordered by published date descending.
 182 |      *   - (optional) Set ``$params`` to the maximum number you want to return.  The default is 3.
 183 |      *
 184 |      * ```twig
 185 |      * {{ dump(blog.query('recent', 3)) }}
 186 |      * ```
 187 |      *
 188 |      * - '**posts**' - Get the ``$params`` blog url path's array of posts.  Limit and order inherent.
 189 |      *
 190 |      * ```twig
 191 |      * {{ dump(blog.query('posts', ['path/one', 'path/two', 'path/three'])) }}
 192 |      * ```
 193 |      *
 194 |      * - '**archives**' - Returns an array of archive information for creating a menu of links.  Ordered by year descending (then months in order), and only includes years if count is greater than 0.
 195 |      *   - (optional) Set ``$params`` to an array of 'Y' years eg. ``array(2015, 2016)``
 196 |      *
 197 |      * ```twig
 198 |      * {{ dump(blog.query('archives')) }}
 199 |      * ```
 200 |      *
 201 |      * - '**authors**' - Returns an array of author information for creating a menu of links.  Ordered by count descending, then author name ascending.
 202 |      *   - (optional) Set ``$params`` to the maximum number you want to return, or to a single author's url path eg. 'joe-bloggs'
 203 |      *
 204 |      * ```twig
 205 |      * {{ dump(blog.query('authors')) }}
 206 |      * ```
 207 |      *
 208 |      * - '**tags**' - Returns an array of tag information for creating a menu of links.  Ordered by count descending, then tag name ascending.
 209 |      *   - (optional) Set ``$params`` to the maximum number you want to return, or to a single tag's url path eg. 'tagged'
 210 |      *
 211 |      * ```twig
 212 |      * {{ dump(blog.query('tags')) }}
 213 |      * ```
 214 |      *
 215 |      * - '**categories**' - Returns an array of category information for creating a menu of links.  Ordered by category name ascending.
 216 |      *
 217 |      * ```twig
 218 |      * {{ dump(blog.query('categories')) }}
 219 |      * ```
 220 |      *
 221 |      *
 222 |      * @param array|string $type
 223 |      * @param mixed        $params
 224 |      * 
 225 |      * @return mixed
 226 |      */
 227 |     public function query($type, $params = null)
 228 |     {
 229 |         $posts = array();
 230 |         if (is_array($type)) { // listings
 231 |             $vars = array();
 232 |             foreach (array('archives', 'authors', 'tags', 'categories', 'default') as $query) {
 233 |                 if (isset($type[$query])) {
 234 |                     $vars = $type[$query];
 235 |                     switch ($query) {
 236 |                         case 'archives':
 237 |                             $vars = (is_array($vars) && count($vars) == 2) ? $vars : false; // array(from, to)
 238 |                             break;
 239 |                         case 'authors':
 240 |                         case 'tags':
 241 |                             $vars = (is_string($vars)) ? $vars : false; // path
 242 |                             break;
 243 |                         case 'categories':
 244 |                             $vars = (is_string($vars) || (is_array($vars) && ctype_digit(implode('', $vars)))) ? $vars : false;
 245 |                             break; // path (string) or category_id's (array)
 246 |                     }
 247 |                     break;
 248 |                 }
 249 |             }
 250 |             if ($vars === false) {
 251 |                 return;
 252 |             }
 253 |             // $count = (is_object($params) && empty($params->limit)) ? false : true; // $params instanceof Pagination
 254 |             $count = (is_object($params) && !empty($params->limit)) ? false : true; // $params instanceof Pagination
 255 |             if ($count && isset($type['count'])) {
 256 |                 return $type['count'];
 257 |             }
 258 |             switch ($query) {
 259 |                 case 'archives':
 260 |                     list($from, $to) = $vars;
 261 |                     $vars = array($to * -1, $from * -1);
 262 |                     if ($count) {
 263 |                         return $this->db->value(array(
 264 |                             'SELECT COUNT(*) FROM blog',
 265 |                             'WHERE featured <= 0 AND published >= ? AND published <= ?',
 266 |                         ), $vars);
 267 |                     } else {
 268 |                         $posts = $this->db->ids(array(
 269 |                             'SELECT id FROM blog',
 270 |                             'WHERE featured <= 0 AND published >= ? AND published <= ?',
 271 |                             'ORDER BY featured, published, updated ASC'.$params->limit,
 272 |                         ), $vars);
 273 |                     }
 274 |                     break;
 275 | 
 276 |                 case 'authors':
 277 |                     if ($count) {
 278 |                         return $this->db->value(array(
 279 |                             'SELECT COUNT(*) FROM blog AS b',
 280 |                             'INNER JOIN authors ON b.author_id = authors.id',
 281 |                             'WHERE b.featured <= 0 AND b.published < 0 AND b.updated < 0 AND authors.path = ?',
 282 |                         ), $vars);
 283 |                     } else {
 284 |                         $posts = $this->db->ids(array(
 285 |                             'SELECT b.id FROM blog AS b',
 286 |                             'INNER JOIN authors ON b.author_id = authors.id',
 287 |                             'WHERE b.featured <= 0 AND b.published < 0 AND b.updated < 0 AND authors.path = ?',
 288 |                             'ORDER BY b.featured, b.published, b.updated ASC'.$params->limit,
 289 |                         ), $vars);
 290 |                     }
 291 |                     break;
 292 | 
 293 |                 case 'tags':
 294 |                     if ($count) {
 295 |                         return $this->db->value(array(
 296 |                             'SELECT COUNT(*) FROM tagged AS t',
 297 |                             'INNER JOIN blog AS b ON t.blog_id = b.id',
 298 |                             'INNER JOIN tags ON t.tag_id = tags.id',
 299 |                             'WHERE b.featured <= 0 AND b.published < 0 AND tags.path = ?',
 300 |                             'GROUP BY tags.id',
 301 |                         ), $vars);
 302 |                     } else {
 303 |                         $posts = $this->db->ids(array(
 304 |                             'SELECT b.id FROM tagged AS t',
 305 |                             'INNER JOIN blog AS b ON t.blog_id = b.id',
 306 |                             'INNER JOIN tags ON t.tag_id = tags.id',
 307 |                             'WHERE b.featured <= 0 AND b.published < 0 AND tags.path = ?',
 308 |                             'ORDER BY b.featured, b.published, b.updated ASC'.$params->limit,
 309 |                         ), $vars);
 310 |                     }
 311 |                     break;
 312 | 
 313 |                 case 'categories':
 314 |                     if (isset($type['search'])) {
 315 |                         if (!is_string($vars)) {
 316 |                             $vars = $this->db->value('SELECT path FROM categories WHERE id = ?', array_shift($vars));
 317 |                         }
 318 |                         if (empty($vars)) {
 319 |                             return;
 320 |                         }
 321 |                         $phrase = $type['search'];
 322 |                         $category = 'blog/'.$vars;
 323 |                         $weights = (isset($type['weights']) && is_array($type['weights'])) ? $type['weights'] : array();
 324 |                         if ($count) {
 325 |                             $sitemap = new Sitemap();
 326 |                             $count = $sitemap->count($phrase, $category);
 327 |                             unset($sitemap);
 328 | 
 329 |                             return $count;
 330 |                         } else {
 331 |                             $sitemap = new Sitemap();
 332 |                             $includes = array();
 333 |                             foreach ($sitemap->search($phrase, $category, $params->limit, $weights) as $row) {
 334 |                                 $posts[] = $row['id'];
 335 |                                 $includes[$row['id']] = array('snippet' => $row['snippet'], 'words' => $row['words']);
 336 |                             }
 337 |                             unset($sitemap);
 338 |                             $posts = $this->info($posts);
 339 |                             foreach ($posts as $id => $row) {
 340 |                                 $posts[$id] = array_merge($row, $includes[$id]);
 341 |                             }
 342 | 
 343 |                             return $posts;
 344 |                         }
 345 |                     }
 346 |                     if (!is_array($vars)) {
 347 |                         $hier = new Hierarchy($this->db, 'categories');
 348 |                         $vars = array_keys($hier->tree(array('path'), 'path', $vars));
 349 |                         unset($hier);
 350 |                     }
 351 |                     if (empty($vars)) {
 352 |                         return;
 353 |                     }
 354 |                     $categories = implode(', ', $vars);
 355 |                     if ($count) {
 356 |                         return $this->db->value(array(
 357 |                             'SELECT COUNT(*) FROM blog',
 358 |                             'WHERE featured <= 0 AND published < 0 AND category_id IN('.$categories.')',
 359 |                         ), $vars);
 360 |                     } else {
 361 |                         $posts = $this->db->ids(array(
 362 |                             'SELECT id FROM blog',
 363 |                             'WHERE featured <= 0 AND published < 0 AND category_id IN('.$categories.')',
 364 |                             'ORDER BY featured, published, updated ASC'.$params->limit,
 365 |                         ), $vars);
 366 |                     }
 367 |                     break;
 368 | 
 369 |                 default:
 370 |                     if (isset($type['search'])) {
 371 |                         $phrase = $type['search'];
 372 |                         $weights = (isset($type['weights']) && is_array($type['weights'])) ? $type['weights'] : array();
 373 |                         if ($count) {
 374 |                             $sitemap = new Sitemap();
 375 |                             $count = $sitemap->count($phrase, 'blog');
 376 |                             unset($sitemap);
 377 | 
 378 |                             return $count;
 379 |                         } else {
 380 |                             $sitemap = new Sitemap();
 381 |                             $includes = array();
 382 |                             foreach ($sitemap->search($phrase, 'blog', $params->limit, $weights) as $row) {
 383 |                                 $posts[] = $row['id'];
 384 |                                 $includes[$row['id']] = array('snippet' => $row['snippet'], 'words' => $row['words']);
 385 |                             }
 386 |                             unset($sitemap);
 387 |                             $posts = $this->info($posts);
 388 |                             foreach ($posts as $id => $row) {
 389 |                                 $posts[$id] = array_merge($row, $includes[$id]);
 390 |                             }
 391 | 
 392 |                             return $posts;
 393 |                         }
 394 |                     }
 395 |                     if ($count) {
 396 |                         return $this->db->value(array(
 397 |                             'SELECT COUNT(*) FROM blog',
 398 |                             'WHERE featured <= 0 AND published < 0',
 399 |                         ), $vars);
 400 |                     } else {
 401 |                         $posts = $this->db->ids(array(
 402 |                             'SELECT id FROM blog',
 403 |                             'WHERE featured <= 0 AND published < 0',
 404 |                             'ORDER BY featured, published, updated ASC'.$params->limit,
 405 |                         ), $vars);
 406 |                     }
 407 |                     break;
 408 |             }
 409 | 
 410 |             return $this->info($posts);
 411 |         }
 412 |         switch ($type) {
 413 |             case 'similar': // optional (string|array) keywords (ordered by RANK) - default Page::html()->keywords
 414 |                 $keywords = Page::html()->keywords;
 415 |                 $limit = $params;
 416 |                 if (is_array($params)) {
 417 |                     list($limit, $keywords) = (count($params) == 1) ? each($params) : $params;
 418 |                 }
 419 |                 if (!empty($keywords) && !empty($limit) && is_numeric($limit)) {
 420 |                     if (!is_array($keywords)) {
 421 |                         $keywords = array_map('trim', explode(',', $keywords));
 422 |                     }
 423 |                     if (!empty($keywords)) {
 424 |                         $current = Page::html()->url['path'];
 425 |                         $sitemap = new Sitemap();
 426 |                         foreach ($sitemap->search('"'.implode('" OR "', $keywords).'"', 'blog', $limit, array(0, 0, 0, 1, 0), 'AND m.path != "'.$current.'"') as $row) {
 427 |                             $posts[] = $row['id'];
 428 |                         }
 429 |                         unset($sitemap);
 430 |                         $posts = $this->info($posts);
 431 |                     }
 432 |                 }
 433 |                 break;
 434 | 
 435 |             case 'featured':
 436 |                 $limit = (is_numeric($params)) ? ' LIMIT '.$params : '';
 437 |                 $posts = $this->info($this->db->ids(array(
 438 |                     'SELECT id FROM blog',
 439 |                     'WHERE featured < 0 AND published < 0',
 440 |                     'ORDER BY featured, published, updated ASC'.$limit,
 441 |                 )));
 442 |                 break;
 443 | 
 444 |             case 'recent':
 445 |                 $limit = (is_numeric($params)) ? $params : 3;
 446 |                 $posts = $this->info($this->db->ids(array(
 447 |                     'SELECT id FROM blog',
 448 |                     'WHERE featured = 0 AND published < 0',
 449 |                     'ORDER BY featured, published, updated ASC LIMIT '.$limit,
 450 |                 )));
 451 |                 break;
 452 | 
 453 |             case 'posts': // (array) paths (limit and order inherent)
 454 |                 if (!empty($params)) {
 455 |                     foreach ((array) $params as $path) {
 456 |                         $posts[$path] = '';
 457 |                     }
 458 |                     foreach ($this->db->all(array(
 459 |                         'SELECT path, id',
 460 |                         'FROM blog',
 461 |                         'WHERE path IN('.implode(', ', array_fill(0, count($posts), '?')).')',
 462 |                     ), array_keys($posts), 'assoc') as $row) {
 463 |                         $posts[$row['path']] = $row['id'];
 464 |                     }
 465 |                     $posts = $this->info(array_values(array_filter($posts)));
 466 |                 }
 467 |                 break;
 468 | 
 469 |             case 'archives': // optional (array) years (ordered by year DESC, and only starts if count > 0) - default all, no limit
 470 |                 $years = (is_array($params)) ? $params : array();
 471 |                 if (empty($years)) {
 472 |                     $times = $this->db->row('SELECT ABS(MAX(published)) AS begin, ABS(MIN(published)) AS end FROM blog WHERE featured <= 0 AND published < 0', '', 'assoc');
 473 |                     if (!is_null($times['end'])) {
 474 |                         $years = range(date('Y', $times['begin']), date('Y', $times['end']));
 475 |                     }
 476 |                 }
 477 |                 $months = array('Jan' => 1, 'Feb' => 2, 'Mar' => 3, 'Apr' => 4, 'May' => 5, 'Jun' => 6, 'Jul' => 7, 'Aug' => 8, 'Sep' => 9, 'Oct' => 10, 'Nov' => 11, 'Dec' => 12);
 478 |                 $archives = array();
 479 |                 foreach ($years as $Y) {
 480 |                     foreach ($months as $M => $n) {
 481 |                         $to = mktime(23, 59, 59, $n + 1, 0, $Y) * -1;
 482 |                         $from = mktime(0, 0, 0, $n, 1, $Y) * -1;
 483 |                         $archives[] = "SUM(CASE WHEN featured <= 0 AND published >= {$to} AND published <= {$from} THEN 1 ELSE 0 END) AS {$M}{$Y}";
 484 |                     }
 485 |                 }
 486 |                 if (!empty($archives) && $archives = $this->db->row(array('SELECT', implode(",\n", $archives), 'FROM blog'), '', 'assoc')) {
 487 |                     $page = Page::html();
 488 |                     foreach ($archives as $date => $count) {
 489 |                         $time = mktime(0, 0, 0, $months[substr($date, 0, 3)], 15, substr($date, 3));
 490 |                         list($Y, $M, $m) = explode(' ', date('Y M m', $time));
 491 |                         if (!isset($posts[$Y])) {
 492 |                             $posts[$Y] = array('count' => 0, 'url' => $page->url('blog/listings', 'archives', $Y));
 493 |                         }
 494 |                         $posts[$Y]['months'][$M] = array('url' => $page->url('blog/listings', 'archives', $Y, $m), 'count' => $count, 'time' => $time);
 495 |                         $posts[$Y]['count'] += $count;
 496 |                     }
 497 |                 }
 498 |                 break;
 499 | 
 500 |             case 'authors': // optional (int) limit or (string) path (ordered by count DESC, then author name ASC)
 501 |                 $path = (!is_int($params) && !empty($params)) ? (string) $params : '';
 502 |                 $operator = (!empty($path)) ? '=' : '!=';
 503 |                 $authors = $this->db->all(array(
 504 |                     'SELECT COUNT(*) AS count, authors.path, authors.name, ABS(MIN(b.published)) AS latest',
 505 |                     'FROM blog AS b',
 506 |                     'INNER JOIN authors ON b.author_id = authors.id',
 507 |                     'WHERE b.featured <= 0 AND b.published < 0 AND b.updated < 0 AND authors.path '.$operator.' ?',
 508 |                     'GROUP BY authors.id',
 509 |                     'ORDER BY authors.name ASC',
 510 |                 ), $path, 'assoc');
 511 |                 $authored = array();
 512 |                 foreach ($authors as $author) {
 513 |                     $authored[$author['path']] = $author['count'];
 514 |                 }
 515 |                 arsort($authored);
 516 |                 if (is_int($params)) {
 517 |                     $authored = array_slice($authored, 0, $params, true);
 518 |                 }
 519 |                 foreach ($authors as $author) {
 520 |                     if (isset($authored[$author['path']])) {
 521 |                         $info = $this->configInfo('authors', $author['path'], $author['name']);
 522 |                         $info['latest'] = $author['latest'];
 523 |                         $info['count'] = $author['count'];
 524 |                         $posts[] = $info;
 525 |                     }
 526 |                 }
 527 |                 if (!empty($path) && !empty($posts)) {
 528 |                     $posts = array_shift($posts);
 529 |                 }
 530 |                 break;
 531 | 
 532 |             case 'tags': // optional (int) limit or (string) path (ordered by count DESC, then tag name ASC)
 533 |                 $path = (!is_int($params) && !empty($params)) ? (string) $params : '';
 534 |                 $operator = (!empty($path)) ? '=' : '!=';
 535 |                 $tags = $this->db->all(array(
 536 |                     'SELECT COUNT(*) AS count, tags.path, tags.name, ABS(MIN(b.published)) AS latest',
 537 |                     'FROM tagged AS t',
 538 |                     'INNER JOIN blog AS b ON t.blog_id = b.id',
 539 |                     'INNER JOIN tags ON t.tag_id = tags.id',
 540 |                     'WHERE b.featured <= 0 AND b.published < 0 AND tags.path '.$operator.' ?',
 541 |                     'GROUP BY tags.id',
 542 |                     'ORDER BY tags.name ASC',
 543 |                 ), $path, 'assoc');
 544 |                 $tagged = array();
 545 |                 foreach ($tags as $tag) {
 546 |                     $tagged[$tag['path']] = $tag['count'];
 547 |                 }
 548 |                 arsort($tagged);
 549 |                 if (is_int($params)) {
 550 |                     $tagged = array_slice($tagged, 0, $params, true);
 551 |                 }
 552 |                 if (count($tagged) > 0) {
 553 |                     // http://en.wikipedia.org/wiki/Tag_cloud
 554 |                     // http://stackoverflow.com/questions/18790677/what-algorithm-can-i-use-to-sort-tags-for-tag-cloud?rq=1
 555 |                     // http://stackoverflow.com/questions/227/whats-the-best-way-to-generate-a-tag-cloud-from-an-array-using-h1-through-h6-fo
 556 |                     $min = min($tagged);
 557 |                     $range = max(.01, max($tagged) - $min) * 1.0001;
 558 |                     foreach ($tags as $tag) {
 559 |                         if (isset($tagged[$tag['path']])) {
 560 |                             $info = $this->configInfo('tags', $tag['path'], $tag['name']);
 561 |                             $info['latest'] = $tag['latest'];
 562 |                             $info['count'] = $tag['count'];
 563 |                             if (!empty($path)) {
 564 |                                 $posts = $info;
 565 |                                 break;
 566 |                             }
 567 |                             $info['rank'] = ceil(((4 * ($tag['count'] - $min)) / $range) + 1);
 568 |                             $posts[] = $info;
 569 |                         }
 570 |                     }
 571 |                 }
 572 |                 break;
 573 | 
 574 |             case 'categories': // (ordered by category name ASC) - no limit
 575 |                 if (is_array($params) && isset($params['nest']) && isset($params['tree'])) {
 576 |                     foreach ($params['nest'] as $id => $subs) {
 577 |                         $category = $params['tree'][$id];
 578 |                         $posts[$id] = $this->configInfo('categories', $category['path'], $category['name']);
 579 |                         $posts[$id]['count'] = $category['count'];
 580 |                         if (!empty($subs)) {
 581 |                             $posts[$id]['subs'] = $this->query('categories', array(
 582 |                                 'nest' => $subs,
 583 |                                 'tree' => $params['tree'],
 584 |                             ));
 585 |                         }
 586 |                     }
 587 | 
 588 |                     return array_values($posts);
 589 |                 }
 590 |                 $hier = new Hierarchy($this->db, 'categories');
 591 |                 $tree = $hier->tree(array('path', 'name'));
 592 |                 $counts = $hier->counts('blog', 'category_id');
 593 |                 foreach ($tree as $id => $fields) {
 594 |                     $tree[$id]['count'] = (isset($counts[$id])) ? $counts[$id] : 0;
 595 |                 }
 596 |                 $nest = $hier->nestify($tree);
 597 |                 $slice = array();
 598 |                 foreach ($nest as $id => $subs) {
 599 |                     if ($tree[$id]['count'] > 0) {
 600 |                         $slice[$id] = $tree[$id]['count'];
 601 |                     }
 602 |                 }
 603 |                 arsort($slice);
 604 |                 if (is_int($params)) {
 605 |                     $slice = array_slice($slice, 0, $params, true);
 606 |                 }
 607 |                 foreach ($nest as $id => $subs) {
 608 |                     if (!isset($slice[$id])) {
 609 |                         unset($nest[$id]);
 610 |                     }
 611 |                 }
 612 |                 if (!empty($slice)) {
 613 |                     $posts = $this->query('categories', array(
 614 |                         'nest' => $nest,
 615 |                         'tree' => $tree,
 616 |                     ));
 617 |                 }
 618 |                 break;
 619 |         }
 620 | 
 621 |         return $posts;
 622 |     }
 623 | 
 624 |     /**
 625 |      * Analyzes a blog 'index.html.twig' file **$path** and performes any database CRUD operations that may be needed.  We do this every time a blog page is visited, but this helps to speed up the process if you are doing things programatically.  If you are making lots of changes, then just delete the Blog.db file and everything will be updated.
 626 |      * 
 627 |      * @param string $path A folder with an 'index.html.twig' file.
 628 |      * 
 629 |      * @return mixed Either ''false`` if the file does not exist, or the database id if it does.
 630 |      */
 631 |     public function file($path)
 632 |     {
 633 |         $blog = $this->db->row('SELECT id, path, updated, search, content FROM blog WHERE path = ?', $path, 'assoc');
 634 |         if (!$current = $this->blogInfo($path)) { // delete
 635 |             if ($blog) {
 636 |                 $this->db->exec('DELETE FROM blog WHERE id = ?', $blog['id']);
 637 |                 $this->db->exec('DELETE FROM tagged WHERE blog_id = ?', $blog['id']);
 638 |                 $sitemap = new Sitemap();
 639 |                 $sitemap->delete($blog['path']);
 640 |                 unset($sitemap);
 641 |             }
 642 | 
 643 |             return false;
 644 |         } elseif ($blog) { // update
 645 |             foreach (array('updated', 'search', 'content') as $field) {
 646 |                 if ($current[$field] != $blog[$field]) {
 647 |                     $updated = $this->db->update('blog', 'id', array($blog['id'] => $current));
 648 |                     $this->db->exec('DELETE FROM tagged WHERE blog_id = ?', $blog['id']);
 649 |                     break;
 650 |                 }
 651 |             }
 652 |             if (!isset($updated)) {
 653 |                 return $blog['id'];
 654 |             }
 655 |         } else { // insert
 656 |             $blog = $current;
 657 |             $blog['id'] = $this->db->insert('blog', $current);
 658 |         }
 659 |         $page = unserialize($current['page']);
 660 |         if (isset($page['keywords'])) {
 661 |             $tags = array_filter(array_map('trim', explode(',', $page['keywords'])));
 662 |             foreach ($tags as $tag) {
 663 |                 $this->db->insert('tagged', array(
 664 |                     'blog_id' => $blog['id'],
 665 |                     'tag_id' => $this->getId('tags', $tag),
 666 |                 ));
 667 |             }
 668 |         }
 669 |         $sitemap = new Sitemap();
 670 |         if (!$current['search']) {
 671 |             $sitemap->delete($blog['path']);
 672 |         } else {
 673 |             $category = 'blog';
 674 |             if ($current['category_id'] > 0) {
 675 |                 $category .= '/'.array_search($current['category_id'], $this->ids['categories']);
 676 |             }
 677 |             $sitemap->upsert($category, array(
 678 |                 'id' => $blog['id'],
 679 |                 'path' => $blog['path'],
 680 |                 'title' => $current['title'],
 681 |                 'description' => (isset($page['description'])) ? (string) $page['description'] : '',
 682 |                 'keywords' => (isset($page['keywords'])) ? (string) $page['keywords'] : '',
 683 |                 'image' => (isset($page['image'])) ? (string) $page['image'] : '',
 684 |                 'content' => $current['content'],
 685 |                 'updated' => $current['updated'],
 686 |             ));
 687 |         }
 688 |         unset($sitemap);
 689 |         $this->updateConfig();
 690 | 
 691 |         return $blog['id'];
 692 |     }
 693 | 
 694 |     /**
 695 |      * Gets all of the information we have for the blog $id(s) you supply.
 696 |      * 
 697 |      * @param int|int[] $ids That correspond to the database.
 698 |      * 
 699 |      * @return array A single row of information if **$ids** is not an array, or multiple rows foreach id in the same order given that you can loop through.
 700 |      */
 701 |     public function info($ids)
 702 |     {
 703 |         $page = Page::html();
 704 |         $single = (is_array($ids)) ? false : true;
 705 |         if (empty($ids)) {
 706 |             return array();
 707 |         }
 708 |         $ids = (array) $ids;
 709 |         $posts = array_flip($ids);
 710 |         foreach ($this->db->all(array(
 711 |             'SELECT b.id, b.page, b.path, b.title, b.content, ABS(b.updated) AS updated, ABS(b.featured) AS featured, ABS(b.published) AS published,',
 712 |             '  a.id AS author_id, a.path AS author_path, a.name AS author_name,',
 713 |             '  (SELECT p.path || "," || p.title FROM blog AS p WHERE p.featured = b.featured AND p.published > b.published AND p.published < 0 ORDER BY p.featured, p.published ASC LIMIT 1) AS previous,',
 714 |             '  (SELECT n.path || "," || n.title FROM blog AS n WHERE n.featured = b.featured AND n.published < b.published AND n.published < 0 ORDER BY n.featured, n.published DESC LIMIT 1) AS next,',
 715 |             '  (SELECT GROUP_CONCAT(p.path, "<!--delimiter-->") FROM categories AS c INNER JOIN categories AS p WHERE c.lft BETWEEN p.lft AND p.rgt AND c.id = b.category_id ORDER BY c.lft) AS category_paths,',
 716 |             '  (SELECT GROUP_CONCAT(p.name, "<!--delimiter-->") FROM categories AS c INNER JOIN categories AS p WHERE c.lft BETWEEN p.lft AND p.rgt AND c.id = b.category_id ORDER BY c.lft) AS category_names,',
 717 |             '  (SELECT GROUP_CONCAT(t.path, "<!--delimiter-->") FROM tagged INNER JOIN tags AS t ON tagged.tag_id = t.id WHERE tagged.blog_id = b.id) AS tag_paths,',
 718 |             '  (SELECT GROUP_CONCAT(t.name, "<!--delimiter-->") FROM tagged INNER JOIN tags AS t ON tagged.tag_id = t.id WHERE tagged.blog_id = b.id) AS tag_names',
 719 |             'FROM blog AS b',
 720 |             'LEFT JOIN authors AS a ON b.author_id = a.id',
 721 |             'WHERE b.id IN('.implode(', ', $ids).')',
 722 |         ), '', 'assoc') as $row) {
 723 |             $post = array(
 724 |                 'page' => unserialize($row['page']),
 725 |                 'path' => $row['path'],
 726 |                 'url' => $page->url('base', $row['path']),
 727 |                 'title' => $row['title'],
 728 |                 'content' => $row['content'],
 729 |                 'updated' => $row['updated'],
 730 |                 'featured' => ($row['featured'] > 0) ? true : false,
 731 |                 'published' => ($row['published'] > 1) ? $row['published'] : (($row['published'] == 1) ? true : false),
 732 |                 'categories' => array(),
 733 |                 'tags' => array(),
 734 |             );
 735 |             if (!empty($row['category_paths'])) {
 736 |                 $cats = array_combine(
 737 |                     explode('<!--delimiter-->', $row['category_paths']),
 738 |                     explode('<!--delimiter-->', $row['category_names'])
 739 |                 );
 740 |                 foreach ($cats as $path => $name) {
 741 |                     $post['categories'][] = $this->configInfo('categories', $path, $name);
 742 |                 }
 743 |             }
 744 |             if (!empty($row['tag_paths'])) {
 745 |                 $tags = array_combine(
 746 |                     explode('<!--delimiter-->', $row['tag_paths']),
 747 |                     explode('<!--delimiter-->', $row['tag_names'])
 748 |                 );
 749 |                 foreach ($tags as $path => $name) {
 750 |                     $post['tags'][] = $this->configInfo('tags', $path, $name);
 751 |                 }
 752 |             }
 753 |             if ($row['published'] > 1) {
 754 |                 $post['author'] = $this->configInfo('authors', $row['author_path'], $row['author_name']);
 755 |                 $post['archive'] = $page->url('blog/listings', 'archives', date('Y/m/d/', $row['published']));
 756 |                 $post['previous'] = $row['previous'];
 757 |                 $post['next'] = $row['next'];
 758 |                 if ($post['previous']) {
 759 |                     $previous = explode(',', $post['previous']);
 760 |                     $post['previous'] = array(
 761 |                         'url' => $page->url('base', array_shift($previous)),
 762 |                         'title' => implode(',', $previous),
 763 |                     );
 764 |                 }
 765 |                 if ($post['next']) {
 766 |                     $next = explode(',', $post['next']);
 767 |                     $post['next'] = array(
 768 |                         'url' => $page->url('base', array_shift($next)),
 769 |                         'title' => implode(',', $next),
 770 |                     );
 771 |                 }
 772 |             }
 773 |             $posts[$row['id']] = $post;
 774 |         }
 775 | 
 776 |         return ($single) ? array_shift($posts) : $posts;
 777 |     }
 778 | 
 779 |     /**
 780 |      * Slugifies a folder path suitable for urls.
 781 |      * 
 782 |      * @param string $path    The path you would like to slugify
 783 |      * @param mixed  $slashes If anything but false, it will allow your path to have slashes.
 784 |      * 
 785 |      * @return string
 786 |      */
 787 |     public function url($path, $slashes = false)
 788 |     {
 789 |         $path = ($slashes !== false) ? explode('/', $path) : array($path);
 790 |         foreach ($path as $key => $value) {
 791 |             $path[$key] = URLify::filter($value);
 792 |         }
 793 | 
 794 |         return implode('/', $path);
 795 |     }
 796 | 
 797 |     /**
 798 |      * Properly formats a title string.
 799 |      * 
 800 |      * @param string $string
 801 |      * 
 802 |      * @return string
 803 |      */
 804 |     public function title($string)
 805 |     {
 806 |         $string = explode(' ', $string);
 807 |         foreach ($string as $key => $value) {
 808 |             if (!empty($value) && mb_strtoupper($value) == $value) {
 809 |                 $string[$key] = mb_strtolower($value);
 810 |             }
 811 |         }
 812 | 
 813 |         return TextFormatter::titleCase(implode(' ', $string));
 814 |     }
 815 | 
 816 |     /**
 817 |      * Retrieves any config value found in the Blog's config.yml file.
 818 |      * 
 819 |      * @param string $key The config array key whose value you would like to retrieve.  For every arg you include we will keep working our way up the config array to find just what you are looking for.
 820 |      * 
 821 |      * @return mixed The config key(s) value, or null if not found.
 822 |      */
 823 |     public function config($key = null)
 824 |     {
 825 |         $args = func_get_args(); // In PHP7, func_get_args() are changed by the time we use them, so we call it now
 826 |         if (is_null($this->config)) {
 827 |             $file = $this->folder.'config.yml';
 828 |             $this->config = (is_file($file)) ? (array) Yaml::parse(file_get_contents($file)) : array();
 829 |             $current = true;
 830 |             foreach (array(
 831 |                 'blog' => array(
 832 |                     'name' => 'Another { BootPress } Site',
 833 |                     'image' => '',
 834 |                     'listings' => '',
 835 |                     'breadcrumb' => 'Blog',
 836 |                     'theme' => 'default',
 837 |                 ),
 838 |             ) as $name => $config) {
 839 |                 foreach ($config as $key => $val) {
 840 |                     if (!isset($this->config[$name][$key]) || !is_string($this->config[$name][$key]) || (empty($this->config[$name][$key]) && !empty($val))) {
 841 |                         $this->config[$name][$key] = $val;
 842 |                         $current = false;
 843 |                     }
 844 |                 }
 845 |             }
 846 |             $page = Page::html();
 847 |             foreach (array('authors', 'categories', 'tags') as $param) {
 848 |                 if (!isset($this->config[$param]) || !is_array($this->config[$param])) {
 849 |                     $this->config[$param] = array();
 850 |                     $current = false;
 851 |                 }
 852 |                 foreach ($this->config[$param] as $key => $val) {
 853 |                     if (is_string($val)) {
 854 |                         $this->config[$param][$key] = array('name' => $val);
 855 |                     }
 856 |                 }
 857 |             }
 858 |             if (!$current) {
 859 |                 file_put_contents($file, Yaml::dump($this->config, 3));
 860 |             }
 861 |         }
 862 |         $value = $this->config;
 863 |         foreach ($args as $key) {
 864 |             if (isset($value[$key])) {
 865 |                 $value = $value[$key];
 866 |             } else {
 867 |                 return;
 868 |             }
 869 |         }
 870 | 
 871 |         return $value;
 872 |     }
 873 | 
 874 |     /**
 875 |      * Compiles an array of useful information.
 876 |      * 
 877 |      * @param string $table Either 'authors', 'categories', or 'tags'.
 878 |      * @param string $path  The ``$table``'s key (a url path).
 879 |      * @param string $name  The default ``$table[$path]``'s name if one is not specified.
 880 |      * 
 881 |      * @return array Either an empty one if not found, or the 'name', 'path', 'url', and 'image' of the ``$table[$path]``.
 882 |      */
 883 |     private function configInfo($table, $path, $name)
 884 |     {
 885 |         if (empty($path)) {
 886 |             return array();
 887 |         }
 888 |         if (!$config = $this->config($table, $path)) {
 889 |             $config = array();
 890 |         }
 891 |         unset($config['path'], $config['url']);
 892 |         $page = Page::html();
 893 |         $config = array_merge(array(
 894 |             'name' => $name,
 895 |             'path' => $path,
 896 |             'url' => ($table == 'categories') ? $page->url('base', $path) : $page->url('blog/listings', $table, $path),
 897 |             'image' => '',
 898 |         ), $config);
 899 |         if (!empty($config['image'])) {
 900 |             $config['image'] = $page->url('blog/config', $config['image']);
 901 |         }
 902 | 
 903 |         return $config;
 904 |     }
 905 | 
 906 |     /**
 907 |      * Looks up an 'index.html.twig' file, and gleans the information in it.
 908 |      * 
 909 |      * @param string $path A blog content folder.
 910 |      * 
 911 |      * @return array|bool An array if the **$path** was found, or ``false`` if not.
 912 |      */
 913 |     private function blogInfo($path)
 914 |     {
 915 |         $page = Page::html();
 916 |         $dir = $this->folder.'content/';
 917 |         if (preg_match('/[^'.$page->url['chars'].'\/]/', $path)) {
 918 |             $seo = $this->url($path, 'slashes');
 919 |             if (is_dir($dir.$path)) {
 920 |                 rename($dir.$path, $dir.$seo);
 921 |             }
 922 |             $path = $seo;
 923 |         }
 924 |         $file = (empty($path)) ? $dir.'index.html.twig' : $dir.$path.'/index.html.twig';
 925 |         if (!is_file($file)) {
 926 |             return false;
 927 |         }
 928 |         $page->set(array(), 'reset');
 929 |         $default = $page->html;
 930 |         if (preg_match('/^\s*{#(?P<meta>.*)#}/sU', file_get_contents($file), $matches)) {
 931 |             $values = Yaml::parse($matches['meta']);
 932 |             if (is_array($values)) {
 933 |                 $page->set($values);
 934 |             }
 935 |         }
 936 |         $content = trim($this->theme->renderTwig($file));
 937 |         // Urlify $page->image, and any other assets we want to pass along
 938 |         $page->set($this->theme->asset($page->html));
 939 |         $set = $page->html;
 940 |         foreach ($default as $key => $value) {
 941 |             if (isset($set[$key]) && $set[$key] == $value) {
 942 |                 unset($set[$key]); // no need to save the same thing over and over again
 943 |             }
 944 |         }
 945 |         $published = $page->published;
 946 |         if (is_string($published) && ($date = strtotime($published))) {
 947 |             if ($date > time()) {
 948 |                 $published = $date; // a future post
 949 |                 $next = ($date = $this->db->settings('future_post')) ? min($date, $published) : $published;
 950 |                 $this->db->settings('future_post', $next);
 951 |             } else {
 952 |                 $published = $date * -1; // a post
 953 |             }
 954 |         } elseif ($published === true) {
 955 |             $published = 1; // a page
 956 |         } else {
 957 |             $published = 0; // unpublished
 958 |         }
 959 | 
 960 |         return array(
 961 |             'page' => serialize($set),
 962 |             'path' => $path,
 963 |             'title' => (string) $page->title,
 964 |             'featured' => ($page->featured === true) ? -1 : 0,
 965 |             'published' => $published,
 966 |             'updated' => filemtime($file) * -1,
 967 |             'author_id' => $this->getId('authors', (string) $page->author),
 968 |             'category_id' => $this->getId('categories', $path),
 969 |             'search' => ($published === 0 || $page->robots === false) ? 0 : 1,
 970 |             'content' => $content,
 971 |         );
 972 |     }
 973 | 
 974 |     /**
 975 |      * Puts everything into the database at once.  It's only called if ``$this->db->created``.
 976 |      */
 977 |     private function updateDatabase()
 978 |     {
 979 |         set_time_limit(0);
 980 |         $blog = $this->db->insert('blog', array('page', 'path', 'title', 'featured', 'published', 'updated', 'author_id', 'category_id', 'search', 'content'));
 981 |         $tagged = $this->db->insert('tagged', array('blog_id', 'tag_id'));
 982 |         $sitemap = new Sitemap();
 983 |         $sitemap->reset('blog');
 984 |         $this->normalizeFolders();
 985 |         $finder = new Finder();
 986 |         $finder->files()->in($this->folder.'content')->name('index.html.twig')->sortByName();
 987 |         foreach ($finder as $file) {
 988 |             if ($info = $this->blogInfo(str_replace('\\', '/', $file->getRelativePath()))) {
 989 |                 $id = $this->db->insert($blog, array_values($info));
 990 |                 $page = unserialize($info['page']);
 991 |                 if (isset($page['keywords']) && !empty($page['keywords'])) {
 992 |                     $tags = array_filter(array_map('trim', explode(',', $page['keywords'])));
 993 |                     foreach ($tags as $tag) {
 994 |                         $this->db->insert($tagged, array($id, $this->getId('tags', $tag)));
 995 |                     }
 996 |                 }
 997 |                 $category = 'blog';
 998 |                 if ($info['category_id'] > 0) {
 999 |                     $category .= '/'.array_search($info['category_id'], $this->ids['categories']);
1000 |                 }
1001 |                 if ($info['search']) {
1002 |                     $sitemap->upsert($category, array(
1003 |                         'id' => $id,
1004 |                         'path' => $info['path'],
1005 |                         'title' => $info['title'],
1006 |                         'description' => (isset($page['description'])) ? (string) $page['description'] : '',
1007 |                         'keywords' => (isset($page['keywords'])) ? (string) $page['keywords'] : '',
1008 |                         'image' => (isset($page['image'])) ? (string) $page['image'] : '',
1009 |                         'content' => $info['content'],
1010 |                         'updated' => $info['updated'],
1011 |                     ));
1012 |                 }
1013 |             }
1014 |         }
1015 |         $sitemap->delete();
1016 |         unset($sitemap);
1017 |         $this->db->close($blog);
1018 |         $this->db->close($tagged);
1019 |         $this->updateConfig();
1020 |     }
1021 | 
1022 |     /**
1023 |      * Recursively goes through the blog's 'content' folder, and fixes any malnamed directories.
1024 |      * 
1025 |      * @param string $path There is nothing to see here.  This value gets passed within the method itself.
1026 |      */
1027 |     private function normalizeFolders($path = null)
1028 |     {
1029 |         $page = Page::html();
1030 |         $dir = $this->folder.'content/';
1031 |         // normalize
1032 |         if ($path && preg_match('/[^'.$page->url['chars'].'\/]/', $path)) {
1033 |             $seo = $this->url($path, 'slashes');
1034 |             if (is_dir($dir.$path)) {
1035 |                 rename($dir.$path, $dir.$seo);
1036 |             }
1037 |             $path = $seo;
1038 |         }
1039 |         // folders
1040 |         foreach (glob($page->dir($dir, $path).'*', GLOB_ONLYDIR) as $folder) {
1041 |             $this->normalizeFolders(substr($folder, strlen($dir)));
1042 |         }
1043 |     }
1044 | 
1045 |     /**
1046 |      * Gets the ID of the ``$table``'s ('categories', 'authors', or 'tags') ``$value``.  If the ``$value`` had not yet been set, then it will be now.  You can know if that is the case by calling ``$this->getId('updated', $table)``.  If the ``$table`` doesn't exist, then we'll let you know if anything has been updated.
1047 |      * 
1048 |      * @param string $table
1049 |      * @param string $value
1050 |      * 
1051 |      * @return int|bool
1052 |      */
1053 |     private function getId($table, $value)
1054 |     {
1055 |         if (is_null($this->ids)) {
1056 |             $this->ids = array(
1057 |                 'updated' => array(
1058 |                     'categories' => false,
1059 |                     'authors' => false,
1060 |                     'tags' => false,
1061 |                 ),
1062 |             );
1063 |         }
1064 |         if ($table == 'updated') {
1065 |             if (isset($this->ids['updated'][$value])) {
1066 |                 return $this->ids['updated'][$value];
1067 |             }
1068 | 
1069 |             return (in_array(true, $this->ids['updated'])) ? true : false;
1070 |         }
1071 |         if ($table == 'categories') {
1072 |             $value = (($slash = strrpos($value, '/')) !== false) ? substr($value, 0, $slash) : '';
1073 |         }
1074 |         if (!isset($this->ids['updated'][$table]) || empty($value)) {
1075 |             return 0;
1076 |         }
1077 |         if (!isset($this->ids[$table])) {
1078 |             $this->ids[$table] = array('' => 0);
1079 |             foreach ($this->db->all('SELECT path, id FROM '.$table, '', 'assoc') as $row) {
1080 |                 $this->ids[$table][$row['path']] = $row['id'];
1081 |             }
1082 |         }
1083 |         $page = Page::html();
1084 |         $path = $value;
1085 |         if (preg_match('/[^'.$page->url['chars'].'\/]/', $value)) {
1086 |             // Categories should never get here as folder names have already been enforced
1087 |             $path = $this->url($value);
1088 |         }
1089 |         if (!isset($this->ids[$table][$path])) {
1090 |             $this->ids['updated'][$table] = true;
1091 |             if ($table == 'categories') {
1092 |                 $parent = 0;
1093 |                 $previous = '';
1094 |                 foreach (explode('/', $path) as $uri) {
1095 |                     if (!isset($this->ids['categories'][$previous.$uri])) {
1096 |                         $category = ($name = $this->config($table, $previous.$uri, 'name')) ? $name : ucwords(str_replace('-', ' ', $uri));
1097 |                         $this->ids['categories'][$previous.$uri] = $this->db->insert('categories', array(
1098 |                             'path' => $previous.$uri,
1099 |                             'name' => $category,
1100 |                             'parent' => $parent,
1101 |                         ));
1102 |                     }
1103 |                     $parent = $this->ids['categories'][$previous.$uri];
1104 |                     $previous .= $uri.'/';
1105 |                 }
1106 |             } else {
1107 |                 if ($name = $this->config($table, $path, 'name')) {
1108 |                     $value = $name;
1109 |                 } elseif (strtolower($value) == $value) { // no uppercase characters
1110 |                     $value = $this->title($value);
1111 |                 }
1112 |                 $this->ids[$table][$path] = $this->db->insert($table, array('path' => $path, 'name' => $value));
1113 |             }
1114 |         }
1115 | 
1116 |         return $this->ids[$table][$path];
1117 |     }
1118 | 
1119 |     /**
1120 |      * Updates the Blog's config.yml file if anything has changed.
1121 |      */
1122 |     private function updateConfig()
1123 |     {
1124 |         if ($this->getId('updated', 'anything') === false) {
1125 |             return;
1126 |         }
1127 |         $yaml = array();
1128 | 
1129 |         // Blog
1130 |         $yaml['blog'] = $this->config('blog');
1131 | 
1132 |         // Authors
1133 |         $yaml['authors'] = array();
1134 |         $authors = $this->config('authors');
1135 |         foreach ($this->db->all(array(
1136 |             'SELECT authors.path, authors.name',
1137 |             'FROM blog AS b',
1138 |             'INNER JOIN authors ON b.author_id = authors.id',
1139 |             'WHERE b.featured <= 0 AND b.published < 0 AND b.updated < 0 AND b.author_id != 0',
1140 |             'GROUP BY authors.id',
1141 |             'ORDER BY authors.name ASC',
1142 |         ), '', 'assoc') as $row) {
1143 |             $merge = (isset($authors[$row['path']])) ? $authors[$row['path']] : array();
1144 |             $yaml['authors'][$row['path']] = array_merge(array(
1145 |                 'name' => $row['name'],
1146 |                 'image' => '',
1147 |             ), $merge);
1148 |             unset($authors[$row['path']]);
1149 |         }
1150 |         foreach ($authors as $path => $values) {
1151 |             $yaml['authors'][$path] = $values;
1152 |         }
1153 | 
1154 |         // Categories
1155 |         $yaml['categories'] = array();
1156 |         $categories = $this->config('categories');
1157 |         $hier = new Hierarchy($this->db, 'categories');
1158 |         if ($this->getId('updated', 'categories')) {
1159 |             $hier->refresh('name');
1160 |         }
1161 |         $tree = $hier->tree(array('path', 'name'));
1162 |         unset($hier);
1163 |         foreach ($tree as $row) {
1164 |             $merge = (isset($categories[$row['path']])) ? $categories[$row['path']] : array();
1165 |             $yaml['categories'][$row['path']] = array_merge(array(
1166 |                 'name' => $row['name'],
1167 |             ), $merge);
1168 |             unset($categories[$row['path']]);
1169 |         }
1170 |         foreach ($categories as $path => $values) {
1171 |             $yaml['categories'][$path] = $values;
1172 |         }
1173 | 
1174 |         // Tags
1175 |         $yaml['tags'] = array();
1176 |         $tags = $this->config('tags');
1177 |         foreach ($this->db->all(array(
1178 |             'SELECT tags.path, tags.name',
1179 |             'FROM tagged AS t',
1180 |             'INNER JOIN tags ON t.tag_id = tags.id',
1181 |             'GROUP BY tags.id',
1182 |             'ORDER BY tags.name ASC',
1183 |         ), '', 'assoc') as $row) {
1184 |             $merge = (isset($tags[$row['path']])) ? $tags[$row['path']] : array();
1185 |             $yaml['tags'][$row['path']] = array_merge(array(
1186 |                 'name' => $row['name'],
1187 |             ), $merge);
1188 |             unset($tags[$row['path']]);
1189 |         }
1190 |         foreach ($tags as $path => $values) {
1191 |             $yaml['tags'][$path] = $values;
1192 |         }
1193 | 
1194 |         file_put_contents($this->folder.'config.yml', Yaml::dump($yaml, 3));
1195 |     }
1196 | }
1197 | 


--------------------------------------------------------------------------------