}
 
    /**
     * Takes an array or object and adds the properties to the parent object
     * @example
     * ```php
     * $data = array('airplane' => '757-200', 'flight' => '5316');
     * $post = new Timber\Post()
     * $post->import(data);
     * echo $post->airplane; //757-200
     * ```
     * @param array|object $info an object or array you want to grab data from to attach to the Timber object
     */
    public function import( $info, $force = false ) {
        if ( is_object($info) ) {
            $info = get_object_vars($info);
        }
        if ( is_array($info) ) {
            foreach ( $info as $key => $value ) {
                if ( $key === '' || ord($key[0]) === 0 ) {
                    continue;
                }
                if ( !empty($key) && $force ) {
                    $this->$key = $value;
                } else if ( !empty($key) && !method_exists($this, $key) ) {
                    $this->$key = $value;
                }
            }
        }
    }
 
 
    /**
     * @ignore
     * @param string  $key
     * @param mixed   $value
     */
    public function update( $key, $value ) {
        update_metadata($this->object_type, $this->ID, $key, $value);
    }

            return $revision->ID;
        }
 
        return false;
    }
 
    /**
     * Initializes a Post
     * @internal
     * @param integer $pid
     */
    protected function init( $pid = false ) {
        if ( $pid === false ) {
            $pid = get_the_ID();
        }
        if ( is_numeric($pid) ) {
            $this->ID = $pid;
        }
        $post_info = $this->get_info($pid);
        $this->import($post_info);
    }
 
    /**
     * Get the URL that will edit the current post/object
     * @internal
     * @deprecated since 1.0
     * @codeCoverageIgnore
     * @see Timber\Post::edit_link
     * @return bool|string
     */
    public function get_edit_url() {
        return $this->edit_link();
    }
 
    /**
     * updates the post_meta of the current object with the given value
     * @param string $field
     * @param mixed $value
     */
    public function update( $field, $value ) {

     */
    public $slug;
 
    /**
     * @var PostType $_type stores the PostType object for the Post
     */
    protected $__type;
 
    /**
     * If you send the constructor nothing it will try to figure out the current post id based on being inside The_Loop
     * @example
     * ```php
     * $post = new Timber\Post();
     * $other_post = new Timber\Post($random_post_id);
     * ```
     * @param mixed $pid
     */
    public function __construct( $pid = null ) {
        $pid = $this->determine_id($pid);
        $this->init($pid);
    }
 
    /**
     * This is helpful for twig to return properties and methods see: https://github.com/fabpot/Twig/issues/2
     * This is also here to ensure that {{ post.class }} remains usable
     * @return mixed
     */
    public function __get( $field ) {
        if ( 'class' === $field ) {
            return $this->css_class();
        }
        return parent::__get($field);
    }
 
    /**
     * This is helpful for twig to return properties and methods see: https://github.com/fabpot/Twig/issues/2
     * This is also here to ensure that {{ post.class }} remains usable
     * @return mixed
     */
    public function __call( $field, $args ) {

         */
        $posts_iterator = apply_filters('timber/class/posts_iterator', $posts_iterator, $returned_posts, $post_class);
 
        parent::__construct($returned_posts, 0, $posts_iterator);
    }
 
    protected static function init( $posts, $post_class ) {
        $returned_posts = array();
        if ( is_null($posts) ) {
            $posts = array();
        }
        foreach ( $posts as $post_object ) {
            $post_type      = get_post_type($post_object);
            $post_class_use = PostGetter::get_post_class($post_type, $post_class);
 
            // Don't create yet another object if $post_object is already of the right type
            if ( is_a($post_object, $post_class_use) ) {
                $post = $post_object;
            } else {
                $post = new $post_class_use($post_object);
            }
 
            if ( isset($post->ID) ) {
                $returned_posts[] = $post;
            }
        }
 
        return self::maybe_set_preview($returned_posts);
    }
 
 
    public function get_posts() {
        return $this->getArrayCopy();
    }
 
    /**
     * @param array $posts
     * @return array
     */
    public static function maybe_set_preview( $posts ) {

<?php
 
namespace Timber;
 
use Timber\Helper;
use Timber\Post;
 
/**
 * Class PostCollection
 *
 * PostCollections are internal objects used to hold a collection of posts.
 *
 * @package Timber
 */
class PostCollection extends \ArrayObject {
 
    public function __construct( $posts = array(), $post_class = '\Timber\Post' ) {
        $returned_posts = self::init($posts, $post_class);
 
        $posts_iterator = 'Timber\PostsIterator';
 
        /**
         * Filters the PostIterator class to use for a PostCollection.
         *
         * This filter is useful if you need to set special values or globals on each post. Because many plugins still
         * rely on The Loop, a custom PostIterator can make it much easier to integrate third party plugins with Timber.
         *
         * @since 1.4.x
         *
         * @param string $posts_iterator The iterator class to use to loop over posts. Default `Timber\PostsIterator`.
         * @param array  $returned_posts An array of posts.
         * @param string $post_class     The post class to use to extend posts with.
         */
        $posts_iterator = apply_filters('timber/class/posts_iterator', $posts_iterator, $returned_posts, $post_class);
 
        parent::__construct($returned_posts, 0, $posts_iterator);
    }
 
    protected static function init( $posts, $post_class ) {
        $returned_posts = array();

 
    /**
     * Gets the amount of found posts in the query.
     *
     * @api
     * @since 1.11.1
     *
     * @return int
     */
    public function found_posts() {
        return $this->_query->found_posts;
    }
 
    public function get_pagination( $prefs ) {
        return new Pagination($prefs, $this->_query);
    }
 
    public function get_posts( $return_collection = false ) {
        if ( isset($this->_query->posts) ) {
            $posts = new PostCollection($this->_query->posts, $this->_posts_class);
            return ($return_collection) ? $posts : $posts->get_posts();
        }
    }
 
    //
    // GET POSTS
    //
    public static function get_query_from_array_of_ids( $query = array() ) {
        if ( !is_array($query) || !count($query) ) {
            return null;
        }
 
        return new \WP_Query(array(
                'post_type'=> 'any',
                'ignore_sticky_posts' => true,
                'post__in' => $query,
                'orderby'  => 'post__in',
                'nopaging' => true
            ));
    }

     */
    public $found_posts = null;
 
    protected $userQuery;
    protected $queryIterator;
    protected $pagination = null;
 
    /**
     * @param mixed       $query
     * @param string     $post_class
     */
    public function __construct( $query = false, $post_class = '\Timber\Post' ) {
        $this->userQuery = $query;
        $this->queryIterator = PostGetter::query_posts($query, $post_class);
 
        if ( $this->queryIterator instanceof QueryIterator ) {
            $this->found_posts = $this->queryIterator->found_posts();
        }
 
        $posts = $this->queryIterator->get_posts();
 
        parent::__construct($posts, $post_class);
    }
 
    /**
     * @return mixed the query the user orignally passed
     * to the pagination object
     */
    protected function get_query() {
        return $this->userQuery;
    }
 
    /**
     * Set pagination for the collection. Optionally could be used to get pagination with custom preferences.
     *
     * @param     array $prefs
     * @return     Timber\Pagination object
     */
    public function pagination( $prefs = array() ) {
        if ( !$this->pagination && is_a($this->queryIterator, 'Timber\QueryIterator') ) {

    }
 
    /**
     * Get context.
     * @api
     * @return array
     */
    public static function get_context() {
        if ( empty(self::$context_cache) ) {
            self::$context_cache['http_host'] = URLHelper::get_scheme().'://'.URLHelper::get_host();
            self::$context_cache['wp_title'] = Helper::get_wp_title();
            self::$context_cache['body_class'] = implode(' ', get_body_class());
 
            self::$context_cache['site'] = new Site();
            self::$context_cache['request'] = new Request();
            $user = new User();
            self::$context_cache['user'] = ($user->ID) ? $user : false;
            self::$context_cache['theme'] = self::$context_cache['site']->theme;
 
            self::$context_cache['posts'] = new PostQuery();
 
            /**
             * @deprecated as of Timber 1.3.0
             * @todo remove in Timber 1.4.*
             */
            self::$context_cache['wp_head'] = new FunctionWrapper( 'wp_head' );
            self::$context_cache['wp_footer'] = new FunctionWrapper( 'wp_footer' );
 
            self::$context_cache = apply_filters('timber_context', self::$context_cache);
            self::$context_cache = apply_filters('timber/context', self::$context_cache);
        }
 
 
        return self::$context_cache;
    }
 
    /**
     * Compile a Twig file.
     *
     * Passes data to a Twig file and returns the output.

 * http://www.gnu.org/licenses/gpl-2.0.html
 */
 
defined('ABSPATH') || die(http_response_code(418));
 
use Gantry\Framework\Gantry;
use Gantry\Framework\Theme;
use Timber\Timber;
 
/*
 * The Template for displaying all single posts
 */
 
$gantry = Gantry::instance();
 
/** @var Theme $theme */
$theme  = $gantry['theme'];
 
// We need to render contents of <head> before plugin content gets added.
$context              = Timber::get_context();
$context['page_head'] = $theme->render('partials/page_head.html.twig', $context);
 
$post            = Timber::query_post();
$context['post'] = $post;
$context['wp_title'] .= ' - ' . $post->title();
 
Timber::render(['single-' . $post->ID . '.html.twig', 'single-' . $post->post_type . '.html.twig', 'single.html.twig'], $context);
 

            }
 
            break;
        }
    }
 
    if ( ! $template ) {
        $template = get_index_template();
    }
 
    /**
     * Filters the path of the current template before including it.
     *
     * @since 3.0.0
     *
     * @param string $template The path of the template to include.
     */
    $template = apply_filters( 'template_include', $template );
    if ( $template ) {
        include $template;
    } elseif ( current_user_can( 'switch_themes' ) ) {
        $theme = wp_get_theme();
        if ( $theme->errors() ) {
            wp_die( $theme->errors() );
        }
    }
    return;
}
 

<?php
/**
 * Loads the WordPress environment and template.
 *
 * @package WordPress
 */
 
if ( ! isset( $wp_did_header ) ) {
 
    $wp_did_header = true;
 
    // Load the WordPress library.
    require_once __DIR__ . '/wp-load.php';
 
    // Set up the WordPress query.
    wp();
 
    // Load the theme template.
    require_once ABSPATH . WPINC . '/template-loader.php';
 
}
 

<?php
/**
 * Front to the WordPress application. This file doesn't do anything, but loads
 * wp-blog-header.php which does and tells WordPress to load the theme.
 *
 * @package WordPress
 */
 
/**
 * Tells WordPress to load the WordPress theme and output it.
 *
 * @var bool
 */
define( 'WP_USE_THEMES', true );
 
/** Loads the WordPress Environment and Template */
require __DIR__ . '/wp-blog-header.php';