/**
* Turns a comma-separated string or array of terms into an array of Term objects
* @param mixed $terms A comma-separated string or array of string terms
* @param string $term_class The class of the Term object type to create from each string
* @param Vocabulary $vocabulary An instance of the Vocabulary that might hold the terms.
* Use existing term object data if found in the specified vocabulary.
* @return Terms An instance of Terms contianing the specified Term objects
**/
public static function parse( $terms, $term_class = 'Term', $vocabulary = null )
{
if ( is_string( $terms ) ) {
if ( '' === $terms ) {
return new Terms();
}
$terms = trim( MultiByte::str_replace( '"', '"', $terms ) );
// dirrty ;)
$rez = array( '\\"'=>':__unlikely_quote__:', '\\\''=>':__unlikely_apos__:' );
$zer = array( ':__unlikely_quote__:'=>'"', ':__unlikely_apos__:'=>"'" );
// escape
$tagstr = str_replace( array_keys( $rez ), $rez, $terms );
// match-o-matic
preg_match_all( '/((("|((?<= )|^)\')\\S([^\\3]*?)\\3((?=[\\W])|$))|[^,])+/u', $tagstr, $matches );
// cleanup
$terms = array_map( 'trim', $matches[0] );
$terms = preg_replace( array_fill( 0, count( $terms ), '/^(["\'])(((?!").)+)(\\1)$/' ), '$2', $terms );
// unescape
$terms = str_replace( array_keys( $zer ), $zer, $terms );
// hooray
}
if ( is_array( $terms ) ) {
if ( $vocabulary instanceof Vocabulary ) {
foreach ( $terms as $k => $term ) {
if ( $saved_term = $vocabulary->get_term( $term, $term_class ) ) {
$terms[$k] = $saved_term;
}
else {
$terms[$k] = new $term_class( $term );
}
}
//Utils::debug($terms);
}
else {
array_walk( $terms, create_function( '&$tag', '$tag = new ' . $term_class . '($tag);' ) );
}
return new Terms( $terms );
}
return new Terms();
}
/**
* Grabs post data and inserts that data into the internal
* handler_vars array, which eventually gets extracted into
* the theme's ( and thereby the template_engine's ) local
* symbol table for use in the theme's templates
*
* This is the default, generic function to grab posts. To
* "filter" the posts retrieved, simply pass any filters to
* the handler_vars variables associated with the post retrieval.
* For instance, to filter by tag, ensure that handler_vars['tag']
* contains the tag to filter by. Simple as that.
*/
public function act_display($paramarray = array('user_filters' => array()))
{
Utils::check_request_method(array('GET', 'HEAD', 'POST'));
// Get any full-query parameters
$possible = array('user_filters', 'fallback', 'posts', 'post', 'content_type');
foreach ($possible as $varname) {
if (isset($paramarray[$varname])) {
${$varname} = $paramarray[$varname];
}
}
/**
* Since handler_vars no longer contains $_GET and $_POST, we have broken out our valid filters into
* an array based upon where we should expect them to be. We then only merge those specific pieces together.
*
* These are ordered so that handler vars gets overwritten by POST, which gets overwritten by GET, should the
* same key exist multiple places. This seemed logical to me at the time, but needs further thought.
*/
$where_filters = array();
$where_filters_hv = Controller::get_handler_vars()->filter_keys($this->valid_filters['handler_vars']);
$where_filters_post = $_POST->filter_keys($this->valid_filters['POST']);
$where_filters_get = $_GET->filter_keys($this->valid_filters['GET']);
$where_filters = $where_filters_hv->merge($where_filters_post, $where_filters_get);
$where_filters['vocabulary'] = array();
if (array_key_exists('tag', $where_filters)) {
$tags = Tags::parse_url_tags($where_filters['tag']);
$not_tag = $tags['exclude_tag'];
$all_tag = $tags['include_tag'];
if (count($not_tag) > 0) {
$where_filters['vocabulary'] = array_merge($where_filters['vocabulary'], array(Tags::vocabulary()->name . ':not:term' => $not_tag));
}
if (count($all_tag) > 0) {
$where_filters['vocabulary'] = array_merge($where_filters['vocabulary'], array(Tags::vocabulary()->name . ':all:term' => $all_tag));
}
$where_filters['tag_slug'] = Utils::slugify($where_filters['tag']);
unset($where_filters['tag']);
}
if (!isset($_GET['preview'])) {
$where_filters['status'] = Post::status('published');
}
if (!isset($posts)) {
$user_filters = Plugins::filter('template_user_filters', $user_filters);
// Work around the tags parameters to Posts::get() being subsumed by the vocabulary parameter
if (isset($user_filters['not:tag'])) {
$user_filters['vocabulary'] = array(Tags::vocabulary()->name . ':not:term' => $user_filters['not:tag']);
unset($user_filters['not:tag']);
}
if (isset($user_filters['tag'])) {
$user_filters['vocabulary'] = array(Tags::vocabulary()->name . ':term_display' => $user_filters['tag']);
unset($user_filters['tag']);
}
$where_filters = $where_filters->merge($user_filters);
$where_filters = Plugins::filter('template_where_filters', $where_filters);
$posts = Posts::get($where_filters);
}
$this->assign('posts', $posts);
if ($posts !== false && count($posts) > 0) {
if (count($posts) == 1) {
$post = $posts instanceof Post ? $posts : reset($posts);
Stack::add('body_class', Post::type_name($post->content_type) . '-' . $post->id);
Stack::add('body_class', 'single');
} else {
$post = reset($posts);
Stack::add('body_class', 'multiple');
}
$this->assign('post', $post);
$type = Post::type_name($post->content_type);
} elseif ($posts === false || isset($where_filters['page']) && $where_filters['page'] > 1 && count($posts) == 0) {
if ($this->template_exists('404')) {
$fallback = array('404');
// Replace template variables with the 404 rewrite rule
$this->request->{URL::get_matched_rule()->name} = false;
$this->request->{URL::set_404()->name} = true;
$this->matched_rule = URL::get_matched_rule();
// 404 status header sent in act_display_404, but we're past
// that, so send it now.
header('HTTP/1.1 404 Not Found', true, 404);
} else {
$this->display('header');
echo '<h2>';
_e("Whoops! 404. The page you were trying to access is not really there. Please try again.");
echo '</h2>';
header('HTTP/1.1 404 Not Found', true, 404);
$this->display('footer');
die;
}
}
$extract = $where_filters->filter_keys('page', 'type', 'id', 'slug', 'posttag', 'year', 'month', 'day', 'tag', 'tag_slug');
foreach ($extract as $key => $value) {
${$key} = $value;
}
$this->assign('page', isset($page) ? $page : 1);
if (!isset($fallback)) {
// Default fallbacks based on the number of posts
$fallback = array('{$type}.{$id}', '{$type}.{$slug}', '{$type}.tag.{$posttag}');
if (count($posts) > 1) {
$fallback[] = '{$type}.multiple';
$fallback[] = 'multiple';
} else {
$fallback[] = '{$type}.single';
$fallback[] = 'single';
}
}
$searches = array('{$id}', '{$slug}', '{$year}', '{$month}', '{$day}', '{$type}', '{$tag}');
$replacements = array(isset($post) && $post instanceof Post ? $post->id : '-', isset($post) && $post instanceof Post ? $post->slug : '-', isset($year) ? $year : '-', isset($month) ? $month : '-', isset($day) ? $day : '-', isset($type) ? $type : '-', isset($tag_slug) ? $tag_slug : '-');
$fallback[] = 'home';
$fallback = Plugins::filter('template_fallback', $fallback, $posts, isset($post) ? $post : null);
$fallback = array_values(array_unique(MultiByte::str_replace($searches, $replacements, $fallback)));
for ($z = 0; $z < count($fallback); $z++) {
if (MultiByte::strpos($fallback[$z], '{$posttag}') !== false && isset($post) && $post instanceof Post) {
$replacements = array();
if ($alltags = $post->tags) {
foreach ($alltags as $current_tag) {
$replacements[] = MultiByte::str_replace('{$posttag}', $current_tag->term, $fallback[$z]);
}
array_splice($fallback, $z, 1, $replacements);
} else {
break;
}
}
}
return $this->display_fallback($fallback);
}
private function generate_title($min = 2, $max = 8)
{
// get a fake paragraph of text that's 1 line long
$text = $this->generate_paragraph(1, 1);
$text = MultiByte::strtolower($text);
// remove commas and periods
$text = MultiByte::str_replace(array('.', ','), '', $text);
$words = explode(' ', $text);
// randomize the words list
shuffle($words);
// we can only get the max number of words the paragraph generated
if ($min > count($words)) {
$min = count($words);
}
if ($max > count($words)) {
$max = count($words);
}
// decide how many words we want
$how_many_words = mt_rand($min, $max);
$title = array();
for ($i = 0; $i < $how_many_words; $i++) {
// snag a random word
$title[] = array_pop($words);
}
$title = implode(' ', $title);
// capitalize the first letter of each word
$title = MultiByte::ucwords($title);
return $title;
}