/**
* Returns the URL for a given $taxonomy and $taxonomy_slug
*
* @param string $folder Folder to use
* @param string $taxonomy Taxonomy to use
* @param string $taxonomy_slug Taxonomy slug to use
* @return string
*/
public static function getURL($folder, $taxonomy, $taxonomy_slug)
{
$url = Config::getSiteRoot() . '/' . $folder . '/' . $taxonomy . '/';
$url .= Config::getTaxonomySlugify() ? Slug::make($taxonomy_slug) : $taxonomy_slug;
// if taxonomies are not case-sensitive, make it lowercase
if (!Config::getTaxonomyCaseSensitive()) {
$url = strtolower($url);
}
return Path::tidy($url);
}
/**
* Filters the current content set down based on the filters given
*
* @param array $filters Filters to use to narrow down content
* @return void
* @throws Exception
*/
public function filter($filters)
{
$hash = Debug::markStart('content', 'filtering');
$filters = Helper::ensureArray($filters);
// nothing to filter, abort
if (!$this->count()) {
return;
}
$since_date = null;
$until_date = null;
$remove_hidden = null;
$remove_drafts = null;
$keep_type = "all";
$folders = null;
$conditions = null;
$located = false;
$where = null;
// standardize filters
// -------------------
$given_filters = $filters;
$filters = array('show_hidden' => isset($given_filters['show_hidden']) ? $given_filters['show_hidden'] : null, 'show_drafts' => isset($given_filters['show_drafts']) ? $given_filters['show_drafts'] : null, 'since' => isset($given_filters['since']) ? $given_filters['since'] : null, 'until' => isset($given_filters['until']) ? $given_filters['until'] : null, 'show_past' => isset($given_filters['show_past']) ? $given_filters['show_past'] : null, 'show_future' => isset($given_filters['show_future']) ? $given_filters['show_future'] : null, 'type' => isset($given_filters['type']) ? strtolower($given_filters['type']) : null, 'folders' => isset($given_filters['folders']) ? $given_filters['folders'] : null, 'conditions' => isset($given_filters['conditions']) ? $given_filters['conditions'] : null, 'located' => isset($given_filters['located']) ? $given_filters['located'] : null, 'where' => isset($given_filters['where']) ? $given_filters['where'] : null);
// determine filters
// -----------------
if (!is_null($filters['show_hidden'])) {
$remove_hidden = !(bool) $filters['show_hidden'];
}
if (!is_null($filters['show_drafts'])) {
$remove_drafts = !(bool) $filters['show_drafts'];
}
if ($filters['since']) {
$since_date = Date::resolve($filters['since']);
}
if ($filters['show_past'] === false && (!$since_date || $since_date < time())) {
$since_date = Config::getEntryTimestamps() ? time() : Date::resolve("today midnight");
}
if ($filters['until']) {
$until_date = Date::resolve($filters['until']);
}
if ($filters['show_future'] === false && (!$until_date || $until_date > time())) {
$until_date = Config::getEntryTimestamps() ? time() : Date::resolve("tomorrow midnight") - 1;
}
if ($filters['type'] === "entries" || $filters['type'] === "pages") {
$keep_type = $filters['type'];
}
if ($filters['folders']) {
$folders = Parse::pipeList($filters['folders']);
}
if ($filters['conditions']) {
$conditions = Parse::conditions($filters['conditions']);
}
if ($filters['located']) {
$located = true;
}
if ($filters['where']) {
$where = $filters['where'];
}
// before we run filters, we need to look through conditions if they
// were set to see if we're going to need content or content_raw
// -----------
if ($conditions) {
// check for conditions involving content
$uses_content = false;
foreach ($conditions as $field => $instructions) {
if (strtolower($field) === 'content') {
$uses_content = true;
break;
}
}
// this uses content, which means we need to load it for all content
if ($uses_content) {
$this->prepare(true, false);
$this->content_parsed = false;
}
}
// run filters
// -----------
foreach ($this->content as $key => $data) {
// entry or page removal
if ($keep_type === "pages" && !$data['_is_page']) {
unset($this->content[$key]);
continue;
} elseif ($keep_type === "entries" && !$data['_is_entry']) {
unset($this->content[$key]);
continue;
}
// check for non-public content
if ($remove_drafts && $data['_is_draft']) {
unset($this->content[$key]);
continue;
}
if ($remove_hidden && $data['_is_hidden']) {
unset($this->content[$key]);
continue;
}
// folder
if ($folders) {
$keep = false;
foreach ($folders as $folder) {
if ($folder === "*" || $folder === "/*") {
// include all
$keep = true;
break;
} elseif (substr($folder, -1) === "*") {
// wildcard check
if (strpos($data['_folder'], substr($folder, 0, -1)) === 0) {
$keep = true;
break;
}
} else {
// plain check
if ($folder == $data['_folder']) {
$keep = true;
break;
}
}
}
if (!$keep) {
unset($this->content[$key]);
continue;
}
}
// since & show past
if ($since_date && $data['datestamp'] && $data['datestamp'] < $since_date) {
unset($this->content[$key]);
continue;
}
// until & show future
if ($until_date && $data['datestamp'] && $data['datestamp'] > $until_date) {
unset($this->content[$key]);
continue;
}
// where
if ($where && !(bool) Parse::template("{{ if " . $where . " }}1{{ else }}0{{ endif }}", $data)) {
unset($this->content[$key]);
continue;
}
// conditions
if ($conditions) {
$case_sensitive_taxonomies = Config::getTaxonomyCaseSensitive();
foreach ($conditions as $field => $instructions) {
$optional = substr($field, -1, 1) == '?';
$field = $optional ? trim(substr($field, 0, -1)) : $field;
try {
// are we looking for existence?
if ($instructions['kind'] === "existence") {
if ($instructions['type'] === "has") {
if (!isset($data[$field]) || !$data[$field]) {
throw new Exception("Does not fit condition");
}
} elseif ($instructions['type'] === "lacks") {
if (isset($data[$field]) && $data[$field]) {
throw new Exception("Does not fit condition");
}
} else {
throw new Exception("Unknown existence type");
}
// are we looking for a comparison?
} elseif ($instructions['kind'] === "comparison") {
$is_taxonomy = Taxonomy::isTaxonomy($field);
$case_sensitive = $is_taxonomy && $case_sensitive_taxonomies;
if (!isset($data[$field])) {
$field = false;
$values = null;
} else {
if ($case_sensitive) {
$field = $data[$field];
$values = $instructions['value'];
} else {
$field = is_array($data[$field]) ? array_map('strtolower', $data[$field]) : strtolower($data[$field]);
$values = is_array($instructions['value']) ? array_map('strtolower', $instructions['value']) : strtolower($instructions['value']);
}
}
// convert boolean-like statements to boolean values
if (is_array($values)) {
foreach ($values as $item => $value) {
if ($value == "true" || $value == "yes") {
$values[$item] = true;
} elseif ($value == "false" || $value == "no") {
$values[$item] = false;
}
}
} else {
if ($values == "true" || $values == "yes") {
$values = true;
} elseif ($values == "false" || $values == "no") {
$values = false;
}
}
// convert date-like statements to timestamps for qualitative comparisons (not equals)
if (in_array($instructions['type'], array('greater than or equal to', 'greater than', 'less than or equal to', 'less than'))) {
if (!is_array($field) && !is_numeric($field) && Date::resolve($field) !== false) {
$field = Date::resolve($field);
}
if (!is_array($values) && !is_numeric($values) && Date::resolve($values) !== false) {
$values = Date::resolve($values);
}
}
// equal comparisons
if ($instructions['type'] == "equal") {
// if this isn't set, it's not equal
if (!$field) {
throw new Exception("Field not set", 1);
}
if (!is_array($field)) {
if ($field != $values) {
throw new Exception("Does not fit condition", 0);
}
} elseif (!in_array($values, $field)) {
throw new Exception("Does not fit condition", 0);
}
// greater than or equal to comparisons
} elseif ($instructions['type'] == "greater than or equal to") {
// if this isn't set, it's not greater than or equal to
if (!$field) {
throw new Exception("Field not set", 1);
}
if (is_array($field) || is_array($values)) {
throw new Exception("Does not fit condition", 0);
}
if (!is_numeric($field) && Date::resolve($field) !== false) {
$field = Date::resolve($field);
}
if (!is_numeric($values) && Date::resolve($values) !== false) {
$values = Date::resolve($values);
}
if (!is_numeric($field) || !is_numeric($values) || $this->toNumber($field) < $this->toNumber($values)) {
throw new Exception("Does not fit condition", 0);
}
// greater than to comparisons
} elseif ($instructions['type'] == "greater than") {
// if this isn't set, it's not less than
if (!$field) {
throw new Exception("Field not set", 1);
}
if (is_array($field) || is_array($values)) {
throw new Exception("Does not fit condition", 0);
}
if (!is_numeric($field) && Date::resolve($field) !== false) {
$field = Date::resolve($field);
}
if (!is_numeric($values) && Date::resolve($values) !== false) {
$values = Date::resolve($values);
}
if (!is_numeric($field) || !is_numeric($values) || $this->toNumber($field) <= $this->toNumber($values)) {
throw new Exception("Does not fit condition", 0);
}
// less than or equal to comparisons
} elseif ($instructions['type'] == "less than or equal to") {
// if this isn't set, it's not less than or equal to
if (!$field) {
throw new Exception("Field not set", 1);
}
if (is_array($field) || is_array($values)) {
throw new Exception("Does not fit condition", 0);
}
if (!is_numeric($field) && Date::resolve($field) !== false) {
$field = Date::resolve($field);
}
if (!is_numeric($values) && Date::resolve($values) !== false) {
$values = Date::resolve($values);
}
if (!is_numeric($field) || !is_numeric($values) || $this->toNumber($field) > $this->toNumber($values)) {
throw new Exception("Does not fit condition", 0);
}
// less than to comparisons
} elseif ($instructions['type'] == "less than") {
// if this isn't set, it's not less than
if (!$field) {
throw new Exception("Field not set", 1);
}
if (is_array($field) || is_array($values)) {
throw new Exception("Does not fit condition", 0);
}
if (!is_numeric($field) && Date::resolve($field) !== false) {
$field = Date::resolve($field);
}
if (!is_numeric($values) && Date::resolve($values) !== false) {
$values = Date::resolve($values);
}
if (!is_numeric($field) || !is_numeric($values) || $this->toNumber($field) >= $this->toNumber($values)) {
throw new Exception("Does not fit condition", 0);
}
// not-equal comparisons
} elseif ($instructions['type'] == "not equal") {
// if this isn't set, it's not equal, continue
if (!$field) {
continue;
}
if (!is_array($field)) {
if ($field == $values) {
throw new Exception("Does not fit condition", 0);
}
} elseif (in_array($values, $field)) {
throw new Exception("Does not fit condition", 0);
}
// contains array comparisons
} elseif ($instructions['type'] == "in") {
if (!$field) {
throw new Exception("Field not set", 1);
}
if (!count(array_intersect(Helper::ensureArray($field), $values))) {
throw new Exception("Does not fit condition", 0);
}
// doesn't contain array comparisons
} elseif ($instructions['type'] == "not in") {
if (!$field) {
throw new Exception("Field not set", 1);
}
if (count(array_intersect(Helper::ensureArray($field), $values))) {
throw new Exception("Does not fit condition", 0);
}
// contains contains-text comparisons
} elseif ($instructions['type'] == 'contains text') {
if (!$field) {
throw new Exception("Field not set", 1);
}
$field = Helper::ensureArray($field);
$found = false;
foreach ($field as $option) {
// do we need to loop through values?
if (is_array($values)) {
// we do
foreach ($values as $value) {
if (strpos($option, strtolower($value)) !== false) {
$found = true;
break;
}
}
if ($found) {
break;
}
} else {
// we don't
if (strpos($option, strtolower($values)) !== false) {
$found = true;
break;
}
}
}
if (!$found) {
throw new Exception("Does not fit condition", 0);
}
}
// we don't know what this is
} else {
throw new Exception("Unknown kind of condition", -1);
}
} catch (Exception $e) {
if ($optional && $e->getCode() === 1) {
// we were only making the comparison if the field exists,
// otherwise, this is ok
continue;
}
// this was not an optional field, and something went wrong
unset($this->content[$key]);
continue;
}
}
}
// located
if ($located && !isset($data['coordinates'])) {
unset($this->content[$key]);
continue;
}
}
Debug::markEnd($hash);
}
/**
* Gets cached content for pages for a certain taxonomy type and value
*
* @param string $taxonomy Taxonomy to use
* @param string $values Values to match (single or array)
* @param mixed $folders Optionally, folders to filter down by
* @return ContentSet
*/
public static function getContentByTaxonomyValue($taxonomy, $values, $folders = null)
{
self::loadCache();
$case_sensitive = Config::getTaxonomyCaseSensitive();
if ($folders) {
$folders = Parse::pipeList($folders);
}
// if an array was sent
if (is_array($values)) {
$files = array();
if (!$case_sensitive) {
$values = array_map('strtolower', $values);
}
// loop through each of the values looking for files
foreach ($values as $value) {
if (!isset(self::$cache["taxonomies"][$taxonomy][$value])) {
continue;
}
// add these file names to the big file list
$files = array_merge($files, self::$cache["taxonomies"][$taxonomy][$value]['files']);
}
// get unique list of files
$files = array_unique($files);
// if a single value was sent
} else {
if (!$case_sensitive) {
$values = strtolower($values);
}
if (!isset(self::$cache["taxonomies"][$taxonomy][$values])) {
$files = array();
} else {
$files = self::$cache["taxonomies"][$taxonomy][$values]['files'];
}
}
// if no files, abort
if (!count($files)) {
return new ContentSet(array());
}
// still here? grab data from cache
$data = array();
foreach ($files as $file) {
$data[] = ContentService::getContent($file);
}
// build a new ContentSet with the data we have
$content_set = new ContentSet($data);
// if there are folders to filter on, filter
if ($folders) {
$content_set->filter(array("folders" => $folders));
}
return $content_set;
}
/**
* Updates the internal content cache
*
* @return boolean
*/
public static function update()
{
// track if any files have changed
$files_changed = false;
// grab length of content type extension
$content_type = Config::getContentType();
$full_content_root = rtrim(Path::tidy(BASE_PATH . "/" . Config::getContentRoot()), "/");
$content_type_length = strlen($content_type) + 1;
// the cache file we'll use
$cache_file = BASE_PATH . "/_cache/_app/content/content.php";
$time_file = BASE_PATH . "/_cache/_app/content/last.php";
$now = time();
// grab the existing cache
$cache = unserialize(File::get($cache_file));
if (!is_array($cache)) {
$cache = array("urls" => array(), "content" => array(), "taxonomies" => array());
}
$last = File::get($time_file);
// grab a list of all files
$finder = new Finder();
$files = $finder->files()->name("*." . Config::getContentType())->in(Config::getContentRoot());
// grab a separate list of files that have changed since last check
$updated_files = clone $files;
$updated = array();
if ($last) {
$updated_files->date(">= " . Date::format("Y-m-d H:i:s", $last));
foreach ($updated_files as $file) {
// we don't want directories, they may show up as being modified
// if a file inside them has changed or been renamed
if (is_dir($file)) {
continue;
}
// this isn't a directory, add it to the list
$updated[] = Path::trimFilesystem(Path::standardize($file->getRealPath()));
}
}
// loop over current files
$current_files = array();
foreach ($files as $file) {
$current_files[] = Path::trimFilesystem(Path::standardize($file->getRealPath()));
}
// get a diff of files we know about and files currently existing
$new_files = array_diff($current_files, $cache['urls']);
// create a master list of files that need updating
$changed_files = array_unique(array_merge($new_files, $updated));
// add to the cache if files have been updated
if (count($changed_files)) {
$files_changed = true;
// build content cache
foreach ($changed_files as $file) {
$file = $full_content_root . $file;
$local_path = Path::trimFilesystem($file);
$local_filename = Path::clean($local_path);
// file parsing
$content = substr(File::get($file), 3);
$divide = strpos($content, "\n---");
$front_matter = trim(substr($content, 0, $divide));
// parse data
$data = YAML::parse($front_matter);
// set additional information
$data['_file'] = $file;
$data['_local_path'] = $local_path;
$data['_order_key'] = null;
$data['datetimestamp'] = null;
// legacy
$data['datestamp'] = null;
$data['date'] = null;
$data['time'] = null;
$data['numeric'] = null;
$data['last_modified'] = filemtime($file);
$data['_is_hidden'] = false;
$data['_is_draft'] = false;
// folder
$data['_folder'] = preg_replace(Pattern::ORDER_KEY, "", str_replace($full_content_root, "", $data['_file']));
$slash = strrpos($data['_folder'], "/");
$data['_folder'] = $slash === 0 ? "" : substr($data['_folder'], 1, $slash - 1);
// fix hidden/draft files
$slug = basename($file, "." . $content_type);
if (substr($slug, 0, 2) === "__") {
$data['_is_hidden'] = true;
$data['slug'] = substr($slug, 2);
} elseif (substr($slug, 0, 1) === "_") {
$data['_is_draft'] = true;
$data['slug'] = substr($slug, 1);
} else {
$data['slug'] = $slug;
}
$data['_basename'] = $data['slug'] . "." . $content_type;
$data['_filename'] = $data['slug'];
$data['_is_entry'] = preg_match(Pattern::ENTRY_FILEPATH, $data['_basename']);
$data['_is_page'] = preg_match(Pattern::PAGE_FILEPATH, $data['_basename']);
// 404 is special
if ($data['_local_path'] === "/404.{$content_type}") {
$local_filename = $local_path;
// order key
} elseif (preg_match(Pattern::DATE_OR_DATETIME, $data['_basename'], $matches)) {
$date = $matches[1] . '-' . $matches[2] . '-' . $matches[3];
$time = NULL;
if (isset($matches[4])) {
$time = substr($matches[4], 0, 2) . ":" . substr($matches[4], 2);
$date = $date . " " . $time;
$data['slug'] = substr($data['slug'], 16);
$data['datetimestamp'] = $data['_order_key'];
} else {
$data['slug'] = substr($data['slug'], 11);
}
$data['_order_key'] = strtotime($date);
$data['datestamp'] = $data['_order_key'];
$data['date'] = Date::format(Config::getDateFormat(), $data['_order_key']);
$data['time'] = $time ? Date::format(Config::getTimeFormat(), $data['_order_key']) : NULL;
} elseif (preg_match(Pattern::NUMERIC, $data['_basename'], $matches)) {
$data['_order_key'] = $matches[1];
$data['numeric'] = $data['_order_key'];
$data['slug'] = substr($data['slug'], strlen($matches[1]) + 1);
} else {
$data['_order_key'] = $data['_basename'];
}
// determine url
$data['url'] = preg_replace("/\\/__?/", "/", $local_filename);
// remove any content type extensions from the end of filename
if (substr($data['url'], -$content_type_length) === "." . $content_type) {
$data['url'] = substr($data['url'], 0, strlen($data['url']) - $content_type_length);
}
// remove any base pages from filename
if (substr($data['url'], -5) == "/page") {
$data['url'] = substr($data['url'], 0, strlen($data['url']) - 5);
}
// add the site root
$data['url'] = Path::tidy(Config::getSiteRoot() . $data['url']);
// add the site URL to get the permalink
$data['permalink'] = Path::tidy(Config::getSiteURL() . $data['url']);
// add to cache file
$cache['content'][$local_path] = $data;
$cache['urls'][$data['url']] = $local_path;
}
}
// loop through all cached content for deleted files
// this isn't as expensive as you'd think in real-world situations
foreach ($cache['content'] as $local_path => $data) {
if (File::exists($full_content_root . $local_path)) {
continue;
}
$files_changed = TRUE;
// remove from content cache
unset($cache['content'][$local_path]);
// remove from url cache
$url = array_search($local_path, $cache['urls']);
if ($url !== FALSE) {
unset($cache['urls'][$url]);
}
}
// build taxonomy cache
// only happens if files were added, updated, or deleted above
if ($files_changed) {
$taxonomies = Config::getTaxonomies();
$force_lowercase = Config::getTaxonomyForceLowercase();
$case_sensitive = Config::getTaxonomyCaseSensitive();
$cache['taxonomies'] = array();
if (count($taxonomies)) {
// set up taxonomy array
foreach ($taxonomies as $taxonomy) {
$cache['taxonomies'][$taxonomy] = array();
}
// loop through content to build cached array
foreach ($cache['content'] as $file => $data) {
// do not grab anything not public
if (array_get($data, '_is_hidden', FALSE) || array_get($data, '_is_draft', FALSE)) {
continue;
}
// loop through the types of taxonomies
foreach ($taxonomies as $taxonomy) {
// if this file contains this type of taxonomy
if (isset($data[$taxonomy])) {
$values = Helper::ensureArray($data[$taxonomy]);
// add the file name to the list of found files for a given taxonomy value
foreach ($values as $value) {
if (!$value) {
continue;
}
$key = !$case_sensitive ? strtolower($value) : $value;
if (!isset($cache['taxonomies'][$taxonomy][$key])) {
$cache['taxonomies'][$taxonomy][$key] = array("name" => $force_lowercase ? strtolower($value) : $value, "files" => array());
}
array_push($cache['taxonomies'][$taxonomy][$key]['files'], $data['url']);
}
}
}
}
}
if (File::put($cache_file, serialize($cache)) === false) {
if (!File::isWritable($cache_file)) {
Log::fatal("Cache folder is not writable.", "core", "content-cache");
}
Log::fatal("Could not write to the cache.", "core", "content-cache");
return false;
}
}
File::put($time_file, $now);
return true;
}
/**
* Filters the current content set down based on the filters given
*
* @param array $filters Filters to use to narrow down content
* @return void
* @throws Exception
*/
public function filter($filters)
{
$filters = Helper::ensureArray($filters);
// nothing to filter, abort
if (!$this->count()) {
return;
}
$since_date = null;
$until_date = null;
$remove_hidden = null;
$keep_type = "all";
$folders = null;
$conditions = null;
$located = false;
// standardize filters
// -------------------
$given_filters = $filters;
$filters = array('show_all' => isset($given_filters['show_all']) ? $given_filters['show_all'] : null, 'since' => isset($given_filters['since']) ? $given_filters['since'] : null, 'until' => isset($given_filters['until']) ? $given_filters['until'] : null, 'show_past' => isset($given_filters['show_past']) ? $given_filters['show_past'] : null, 'show_future' => isset($given_filters['show_future']) ? $given_filters['show_future'] : null, 'type' => isset($given_filters['type']) ? strtolower($given_filters['type']) : null, 'folders' => isset($given_filters['folders']) ? $given_filters['folders'] : null, 'conditions' => isset($given_filters['conditions']) ? $given_filters['conditions'] : null, 'located' => isset($given_filters['located']) ? $given_filters['located'] : null);
// determine filters
// -----------------
if ($filters['show_all'] === false) {
$remove_hidden = true;
}
if ($filters['since']) {
$since_date = Date::resolve($filters['since']);
}
if ($filters['show_past'] === false && (!$since_date || $since_date < time())) {
$since_date = time();
}
if ($filters['until']) {
$until_date = Date::resolve($filters['until']);
}
if ($filters['show_future'] === false && (!$until_date || $until_date > time())) {
$until_date = time();
}
if ($filters['type'] === "entries" || $filters['type'] === "pages") {
$keep_type = $filters['type'];
}
if ($filters['folders']) {
$folders = Helper::parseForFolders($filters['folders']);
}
if ($filters['conditions']) {
$conditions = Parse::conditions($filters['conditions']);
}
if ($filters['located']) {
$located = true;
}
// run filters
// -----------
foreach ($this->content as $key => $data) {
// entry or page removal
if ($keep_type === "pages" && !$data['_is_page']) {
unset($this->content[$key]);
continue;
} elseif ($keep_type === "entries" && !$data['_is_entry']) {
unset($this->content[$key]);
continue;
}
// check if this is hidden content
if ($remove_hidden && strpos($data['_local_path'], "/_") !== false) {
unset($this->content[$key]);
continue;
}
// folder
if ($folders) {
$keep = false;
foreach ($folders as $folder) {
if ($folder === "*" || $folder === "/*") {
// include all
$keep = true;
break;
} elseif (substr($folder, -1) === "*") {
// wildcard check
if (strpos($data['_folder'], substr($folder, 0, -1)) === 0) {
$keep = true;
break;
}
} else {
// plain check
if ($folder == $data['_folder']) {
$keep = true;
break;
}
}
}
if (!$keep) {
unset($this->content[$key]);
continue;
}
}
// since & show past
if ($since_date && $data['datestamp'] && $data['datestamp'] < $since_date) {
unset($this->content[$key]);
continue;
}
// until & show future
if ($until_date && $data['datestamp'] && $data['datestamp'] > $until_date) {
unset($this->content[$key]);
continue;
}
// conditions
if ($conditions) {
$case_sensitive_taxonomies = Config::getTaxonomyCaseSensitive();
foreach ($conditions as $field => $instructions) {
try {
// are we looking for existence?
if ($instructions['kind'] === "existence") {
if ($instructions['type'] === "has") {
if (!isset($data[$field]) || !$data[$field]) {
throw new Exception("Does not fit condition");
}
} elseif ($instructions['type'] === "lacks") {
if (isset($data[$field]) && $data[$field]) {
throw new Exception("Does not fit condition");
}
} else {
throw new Exception("Unknown existence type");
}
// are we looking for a comparison?
} elseif ($instructions['kind'] === "comparison") {
$is_taxonomy = Taxonomy::isTaxonomy($field);
$case_sensitive = $is_taxonomy && $case_sensitive_taxonomies;
if (!isset($data[$field])) {
$field = false;
$values = null;
} else {
if ($case_sensitive) {
$field = $data[$field];
$values = $instructions['value'];
} else {
$field = is_array($data[$field]) ? array_map('strtolower', $data[$field]) : strtolower($data[$field]);
$values = is_array($instructions['value']) ? array_map('strtolower', $instructions['value']) : strtolower($instructions['value']);
}
}
// convert boolean-like statements to boolean values
if (is_array($values)) {
foreach ($values as $item => $value) {
if ($value == "true" || $value == "yes") {
$values[$item] = true;
} elseif ($value == "false" || $value == "no") {
$values[$item] = false;
}
}
} else {
if ($values == "true" || $values == "yes") {
$values = true;
} elseif ($values == "false" || $values == "no") {
$values = false;
}
}
// equal comparisons
if ($instructions['type'] == "equal") {
// if this isn't set, it's not equal
if (!$field) {
throw new Exception("Does not fit condition");
}
if (!is_array($field)) {
if ($field != $values) {
throw new Exception("Does not fit condition");
}
} elseif (!in_array($values, $field)) {
throw new Exception("Does not fit condition");
}
// not-equal comparisons
} elseif ($instructions['type'] == "not equal") {
// if this isn't set, it's not equal, continue
if (!$field) {
continue;
}
if (!is_array($field)) {
if ($field == $values) {
throw new Exception("Does not fit condition");
}
} elseif (in_array($values, $field)) {
throw new Exception("Does not fit condition");
}
// contains comparisons
} elseif ($instructions['type'] == "in") {
if (!isset($field)) {
throw new Exception("Does not fit condition");
}
if (is_array($field)) {
$found = false;
foreach ($field as $option) {
if (in_array($option, $values)) {
$found = true;
break;
}
}
if (!$found) {
throw new Exception("Does not fit condition");
}
} elseif (!in_array($field, $values)) {
throw new Exception("Does not fit condition");
}
}
// we don't know what this is
} else {
throw new Exception("Unknown kind of condition");
}
} catch (Exception $e) {
unset($this->content[$key]);
continue;
}
}
}
// located
if ($located && !isset($data['coordinates'])) {
unset($this->content[$key]);
continue;
}
}
}
/**
* Updates the internal content cache
*
* @return boolean
*/
public static function update()
{
// start measuring
$content_hash = Debug::markStart('caching', 'content');
// track if any files have changed
$files_changed = false;
$settings_changed = false;
$members_changed = false;
// grab length of content type extension
$content_type = Config::getContentType();
$full_content_root = rtrim(Path::tidy(BASE_PATH . "/" . Config::getContentRoot()), "/");
$content_type_length = strlen($content_type) + 1;
// the cache files we'll use
$cache_file = BASE_PATH . '/_cache/_app/content/content.php';
$settings_file = BASE_PATH . '/_cache/_app/content/settings.php';
$structure_file = BASE_PATH . '/_cache/_app/content/structure.php';
$time_file = BASE_PATH . '/_cache/_app/content/last.php';
$members_file = BASE_PATH . '/_cache/_app/members/members.php';
$now = time();
// start measuring settings hash
$settings_hash = Debug::markStart('caching', 'settings');
// check for current and new settings
$settings = unserialize(File::get($settings_file));
if (!is_array($settings)) {
$settings = array('site_root' => '', 'site_url' => '', 'timezone' => '', 'date_format' => '', 'time_format' => '', 'content_type' => '', 'taxonomy' => '', 'taxonomy_case_sensitive' => '', 'taxonomy_force_lowercase' => '', 'entry_timestamps' => '', 'base_path' => '', 'app_version' => '');
}
// look up current settings
$current_settings = array('site_root' => Config::getSiteRoot(), 'site_url' => Config::getSiteURL(), 'timezone' => Config::get('timezone'), 'date_format' => Config::get('date_format'), 'time_format' => Config::get('time_format'), 'content_type' => Config::get('content_type'), 'taxonomy' => Config::getTaxonomies(), 'taxonomy_case_sensitive' => Config::getTaxonomyCaseSensitive(), 'taxonomy_force_lowercase' => Config::getTaxonomyForceLowercase(), 'entry_timestamps' => Config::getEntryTimestamps(), 'base_path' => BASE_PATH, 'app_version' => STATAMIC_VERSION);
// have cache-altering settings changed?
if ($settings !== $current_settings) {
// settings have changed
$settings_changed = true;
// clear the cache and set current settings
$cache = self::getCleanCacheArray();
$settings = $current_settings;
$last = null;
} else {
// grab the existing cache
$cache = unserialize(File::get($cache_file));
if (!is_array($cache)) {
$cache = self::getCleanCacheArray();
}
$last = File::get($time_file);
}
// mark end of settings hash measuring
Debug::markEnd($settings_hash);
// grab a list of all content files
$files = File::globRecursively(Path::tidy(BASE_PATH . '/' . Config::getContentRoot() . '/*'), Config::getContentType());
// grab a separate list of files that have changed since last check
$updated = array();
$current_files = array();
// loop through files, getting local paths and checking for updated files
foreach ($files as $file) {
$local_file = Path::trimFilesystemFromContent(Path::standardize($file));
// add to current files
$current_files[] = $local_file;
// is this updated?
if ($last && File::getLastModified($file) >= $last) {
$updated[] = $local_file;
}
}
// get a diff of files we know about and files currently existing
$known_files = array();
foreach ($cache['urls'] as $url_data) {
array_push($known_files, $url_data['path']);
}
$new_files = array_diff($current_files, $known_files);
// create a master list of files that need updating
$changed_files = array_unique(array_merge($new_files, $updated));
// store a list of changed URLs
$changed_urls = array();
// add to the cache if files have been updated
if (count($changed_files)) {
$files_changed = true;
// build content cache
foreach ($changed_files as $file) {
$file = $full_content_root . $file;
$local_path = Path::trimFilesystemFromContent($file);
// before cleaning anything, check for hidden or draft content
$is_hidden = Path::isHidden($local_path);
$is_draft = Path::isDraft($local_path);
// now clean up the path
$local_filename = Path::clean($local_path);
// file parsing
$content = substr(File::get($file), 3);
$divide = strpos($content, "\n---");
$front_matter = trim(substr($content, 0, $divide));
$content_raw = trim(substr($content, $divide + 4));
// parse data
$data = YAML::parse($front_matter);
if ($content_raw) {
$data['content'] = 'true';
$data['content_raw'] = 'true';
}
// set additional information
$data['_file'] = $file;
$data['_local_path'] = $local_path;
$data['_order_key'] = null;
$data['datetimestamp'] = null;
// legacy
$data['datestamp'] = null;
$data['date'] = null;
$data['time'] = null;
$data['numeric'] = null;
$data['last_modified'] = filemtime($file);
$data['_is_hidden'] = $is_hidden;
$data['_is_draft'] = $is_draft;
// get initial slug (may be changed below)
$data['slug'] = ltrim(basename($file, "." . $content_type), "_");
// folder
$instance = $data['slug'] == 'page' ? 1 : 0;
$data['_folder'] = Path::clean($data['_local_path']);
$slash = Helper::strrpos_count($data['_folder'], '/', $instance);
$data['_folder'] = !$slash ? '' : substr($data['_folder'], 1, $slash - 1);
$data['_folder'] = !strlen($data['_folder']) ? "/" : $data['_folder'];
$data['_basename'] = $data['slug'] . '.' . $content_type;
$data['_filename'] = $data['slug'];
$data['_is_entry'] = preg_match(Pattern::ENTRY_FILEPATH, $data['_basename']);
$data['_is_page'] = preg_match(Pattern::PAGE_FILEPATH, $data['_basename']);
// 404 is special
if ($data['_local_path'] === "/404.{$content_type}") {
$local_filename = $local_path;
// order key: date or datetime
} elseif (preg_match(Pattern::DATE_OR_DATETIME, $data['_basename'], $matches)) {
// order key: date or datetime
$date = $matches[1] . '-' . $matches[2] . '-' . $matches[3];
$time = null;
if (Config::getEntryTimestamps() && isset($matches[4])) {
$time = substr($matches[4], 0, 2) . ":" . substr($matches[4], 2);
$date = $date . " " . $time;
$data['slug'] = substr($data['slug'], 16);
$data['datetimestamp'] = $data['_order_key'];
} else {
$data['slug'] = substr($data['slug'], 11);
}
$data['_order_key'] = strtotime($date);
$data['datestamp'] = $data['_order_key'];
$data['date'] = Date::format(Config::getDateFormat(), $data['_order_key']);
$data['time'] = $time ? Date::format(Config::getTimeFormat(), $data['_order_key']) : null;
// order key: slug is page, back up a level
} elseif ($data['slug'] == 'page' && preg_match(Pattern::NUMERIC, substr($data['_local_path'], Helper::strrpos_count($data['_local_path'], '/', 1)), $matches)) {
// order key: slug is page, back up a level
$data['_order_key'] = $matches[1];
$data['numeric'] = $data['_order_key'];
// order key: numeric
} elseif (preg_match(Pattern::NUMERIC, $data['_basename'], $matches)) {
// order key: numeric
$data['_order_key'] = $matches[1];
$data['numeric'] = $data['_order_key'];
$data['slug'] = substr($data['slug'], strlen($matches[1]) + 1);
// order key: other
} else {
// order key: other
$data['_order_key'] = $data['_basename'];
}
// determine url
$data['url'] = preg_replace('#/__?#', '/', $local_filename);
// remove any content type extensions from the end of filename
if (substr($data['url'], -$content_type_length) === '.' . $content_type) {
$data['url'] = substr($data['url'], 0, strlen($data['url']) - $content_type_length);
}
// remove any base pages from filename
if (substr($data['url'], -5) == '/page') {
$data['url'] = substr($data['url'], 0, strlen($data['url']) - 5);
}
// add the site root
$data['url'] = Path::tidy(Config::getSiteRoot() . $data['url']);
// add the site URL to get the permalink
$data['permalink'] = Path::tidy(Config::getSiteURL() . $data['url']);
// new content
if (!isset($cache['content'][$data['_folder']]) || !is_array($cache['content'][$data['_folder']])) {
$cache['content'][$data['_folder']] = array();
}
$slug_with_extension = $data['_filename'] == 'page' ? substr($data['url'], strrpos($data['url'], '/') + 1) . '/' . $data['_filename'] . "." . $content_type : $data['_filename'] . "." . $content_type;
$cache['content'][$data['_folder']][$slug_with_extension] = array('folder' => $data['_folder'], 'path' => $local_path, 'file' => $slug_with_extension, 'url' => $data['url'], 'data' => $data);
$cache['urls'][$data['url']] = array('folder' => $data['_folder'], 'path' => $local_path, 'file' => $slug_with_extension);
$changed_urls[$data['url']] = true;
}
}
// loop through all cached content for deleted files
// this isn't as expensive as you'd think in real-world situations
foreach ($cache['content'] as $folder => $folder_contents) {
foreach ($folder_contents as $path => $data) {
if (File::exists($full_content_root . $data['path'])) {
// still here, keep it
continue;
}
$files_changed = true;
// get URL
$url = isset($cache['content'][$folder][$path]['url']) ? $cache['content'][$folder][$path]['url'] : null;
// only remove from URLs list if not in changed URLs list
if (!isset($changed_urls[$url]) && !is_null($url)) {
// remove from url cache
unset($cache['urls'][$url]);
}
// remove from content cache
unset($cache['content'][$folder][$path]);
}
}
// build taxonomy cache
// only happens if files were added, updated, or deleted above
if ($files_changed) {
$taxonomies = Config::getTaxonomies();
$force_lowercase = Config::getTaxonomyForceLowercase();
$case_sensitive = Config::getTaxonomyCaseSensitive();
$cache['taxonomies'] = array();
// rebuild taxonomies
if (count($taxonomies)) {
// set up taxonomy array
foreach ($taxonomies as $taxonomy) {
$cache['taxonomies'][$taxonomy] = array();
}
// loop through content to build cached array
foreach ($cache['content'] as $pages) {
foreach ($pages as $item) {
$data = $item['data'];
// loop through the types of taxonomies
foreach ($taxonomies as $taxonomy) {
// if this file contains this type of taxonomy
if (isset($data[$taxonomy])) {
$values = Helper::ensureArray($data[$taxonomy]);
// add the file name to the list of found files for a given taxonomy value
foreach ($values as $value) {
if (!$value) {
continue;
}
$key = !$case_sensitive ? strtolower($value) : $value;
if (!isset($cache['taxonomies'][$taxonomy][$key])) {
$cache['taxonomies'][$taxonomy][$key] = array('name' => $force_lowercase ? strtolower($value) : $value, 'files' => array());
}
array_push($cache['taxonomies'][$taxonomy][$key]['files'], $data['url']);
}
}
}
}
}
}
// build structure cache
$structure = array();
$home = Path::tidy('/' . Config::getSiteRoot() . '/');
foreach ($cache['content'] as $pages) {
foreach ($pages as $item) {
// set up base variables
$parent = null;
// Trim off home and any /page.md ending so that all URLs are treated
// equally regardless of page type.
$order_key = str_replace('/page.md', '', str_replace($home, '', $item['path']));
$sub_order_key = $item['data']['_order_key'];
// does this have a parent (and if so, what is it?)
if ($item['url'] !== $home) {
$parent = $home;
$depth = substr_count(str_replace($home, '/', $item['url']), '/');
$last_slash = strrpos($item['url'], '/', 1);
$last_order_slash = strrpos($order_key, '/', 0);
if ($last_slash !== false) {
$parent = substr($item['url'], 0, $last_slash);
}
if ($last_order_slash !== false) {
$order_key = substr($order_key, 0, $last_order_slash);
}
if ($item['data']['_is_page']) {
$type = $item['data']['slug'] == 'page' ? 'folder' : 'page';
} else {
$type = 'entry';
}
} else {
$depth = 0;
$type = 'folder';
$order_key = $home;
}
$structure[$item['url']] = array('parent' => $parent, 'is_entry' => $item['data']['_is_entry'], 'is_page' => $item['data']['_is_page'], 'is_hidden' => $item['data']['_is_hidden'], 'is_draft' => $item['data']['_is_draft'], 'depth' => $depth, 'order_key' => $order_key ? $order_key : $sub_order_key, 'sub_order_key' => $sub_order_key, 'type' => $type);
}
}
}
// mark ending of content cache measuring
Debug::markEnd($content_hash);
if (!Config::get('disable_member_cache')) {
// build member cache
// ----------------------------------------------------------------
// start measuring
$member_hash = Debug::markStart('caching', 'member');
// grab a list of existing members
$users = File::globRecursively(Path::tidy(Config::getConfigPath() . '/users/*'), 'yaml');
// clone for reuse, set up our list of updated users
$updated = array();
$current_users = array();
foreach ($users as $user) {
$local_file = Path::trimFilesystemFromContent(Path::standardize($user));
// add to current users
$current_users[] = $local_file;
// is this updated?
if ($last && File::getLastModified($user) >= $last) {
$updated[] = $local_file;
}
}
// get users from the file
$members = unserialize(File::get($members_file));
// get a diff of users we know about and files currently existing
$known_users = array();
if (!empty($members)) {
foreach ($members as $username => $member_data) {
$known_users[$username] = $member_data['_path'];
}
}
// create a master list of users that need updating
$changed_users = array_unique(array_merge(array_diff($current_users, $known_users), $updated));
$removed_users = array_diff($known_users, $current_users);
if (count($changed_users)) {
$members_changed = true;
foreach ($changed_users as $user_file) {
// file parsing
$last_slash = strrpos($user_file, '/') + 1;
$last_dot = strrpos($user_file, '.');
$username = substr($user_file, $last_slash, $last_dot - $last_slash);
$content = substr(File::get($user_file), 3);
$divide = strpos($content, "\n---");
$data = YAML::parse(trim(substr($content, 0, $divide)));
$bio_raw = trim(substr($content, $divide + 4));
$data['_path'] = $user_file;
if ($bio_raw) {
$data['biography'] = 'true';
$data['biography_raw'] = 'true';
}
$members[$username] = $data;
}
}
// loop through all cached content for deleted files
// this isn't as expensive as you'd think in real-world situations
if (!empty($removed_users)) {
$members_changed = true;
$members = array_diff_key($members, $removed_users);
}
// mark ending of member cache measuring
Debug::markEnd($member_hash);
}
// write to caches
// --------------------------------------------------------------------
// add file-writing to content-cache actions
$content_hash = Debug::markStart('caching', 'content');
if ($files_changed) {
// store the content cache
if (File::put($cache_file, serialize($cache)) === false) {
if (!File::isWritable($cache_file)) {
Log::fatal('Cache folder is not writable.', 'core', 'content-cache');
}
Log::fatal('Could not write to the cache.', 'core', 'content-cache');
return false;
}
// store the structure cache
if (File::put($structure_file, serialize($structure)) === false) {
if (!File::isWritable($structure_file)) {
Log::fatal('Structure cache file is not writable.', 'core', 'structure-cache');
}
Log::fatal('Could not write to the structure cache.', 'core', 'structure-cache');
return false;
}
}
// mark ending of content cache file write measuring
Debug::markEnd($content_hash);
// add file-writing to settings-cache actions
$settings_hash = Debug::markStart('caching', 'settings');
// store the settings cache
if ($settings_changed) {
if (File::put($settings_file, serialize($settings)) === false) {
if (!File::isWritable($settings_file)) {
Log::fatal('Settings cache file is not writable.', 'core', 'settings-cache');
}
Log::fatal('Could not write to the settings cache file.', 'core', 'settings-cache');
return false;
}
}
// mark ending of settings cache file write measuring
Debug::markEnd($settings_hash);
if (!Config::get('disable_member_cache')) {
// add file-writing to settings-cache actions
$member_hash = Debug::markStart('caching', 'member');
// store the members cache
if ($members_changed) {
if (File::put($members_file, serialize($members)) === false) {
if (!File::isWritable($members_file)) {
Log::fatal('Member cache file is not writable.', 'core', 'member-cache');
}
Log::fatal('Could not write to the member cache file.', 'core', 'member-cache');
return false;
}
}
// mark ending of member cache file write measuring
Debug::markEnd($member_hash);
}
File::put($time_file, $now - 1);
return true;
}
