WordPress plugin to ease the creation of virtual pages.

Controller.php

<?php
namespace GM\VirtualPages;

class Controller implements ControllerInterface {

  private $pages;
  private $loader;
  private $matched;
  
  function __construct( TemplateLoaderInterface $loader ) {
    $this->pages = new \SplObjectStorage;
    $this->loader = $loader;
  }
  
  function init() {
    do_action( 'gm_virtual_pages', $this ); 
  }
  
  function addPage( PageInterface $page ) {
    $this->pages->attach( $page );
    return $page;
  }
  
  function dispatch( $bool, \WP $wp ) {
    if ( $this->checkRequest() && $this->matched instanceof Page ) {
      $this->loader->init( $this->matched );
      $wp->virtual_page = $this->matched;
      do_action( 'parse_request', $wp );
      $this->setupQuery();
      do_action( 'wp', $wp );
      $this->loader->load();
      $this->handleExit();
    }
    return $bool;
  }
  
  private function checkRequest() {
    $this->pages->rewind();
    $path = trim( $this->getPathInfo(), '/' );
    while( $this->pages->valid() ) {
      if ( trim( $this->pages->current()->getUrl(), '/' ) === $path ) {
        $this->matched = $this->pages->current();
        return TRUE;
      }
      $this->pages->next();
    }
  }        
  
  private function getPathInfo() {
    $home_path = parse_url( home_url(), PHP_URL_PATH );
    return preg_replace( "#^/?{$home_path}/#", '/', add_query_arg( array() ) );
  }
  
  private function setupQuery() {
    global $wp_query;
    $wp_query->init();
    $wp_query->is_page       = TRUE;
    $wp_query->is_singular   = TRUE;
    $wp_query->is_home       = FALSE;
    $wp_query->found_posts   = 1;
    $wp_query->post_count    = 1;
    $wp_query->max_num_pages = 1;
    $posts = (array) apply_filters(
      'the_posts', array( $this->matched->asWpPost() ), $wp_query
    );
    $post = $posts[0];
    $wp_query->posts          = $posts;
    $wp_query->post           = $post;
    $wp_query->queried_object = $post;
    $GLOBALS['post']          = $post;
    $wp_query->virtual_page   = $post instanceof \WP_Post && isset( $post->is_virtual )
      ? $this->matched
      : NULL;
  }
  
  public function handleExit() {
    exit();
  }
}

ControllerInterface.php

<?php
namespace GM\VirtualPages;

interface ControllerInterface {

  /**
   * Init the controller, fires the hook that allow consumer to add pages
   */
  function init();
  
  /**
   * Register a page object in the controller
   *
   * @param  \GM\VirtualPages\Page $page
   * @return \GM\VirtualPages\Page
   */
  function addPage( PageInterface $page );
  
  /**
   * Run on 'do_parse_request' and if the request is for one of the registerd
   * setup global variables, fire core hooks, requires page template and exit.
   *
   * @param boolean $bool The boolean flag value passed by 'do_parse_request'
   * @param \WP $wp       The global wp object passed by 'do_parse_request'
   */  
  function dispatch( $bool, \WP $wp );
  
}

gm-virtual-pages.php

<?php namespace GM\VirtualPages;
/*
Plugin Name: GM Virtual Pages
Plugin URI: http://wordpress.stackexchange.com/questions/162240/custom-pages-with-plugin
Description: Virtual pages made easy.
Author: Giuseppe Mazzapica
Author URI: http://gm.zoomlab.it
License: GPL-3.0
*/

/*
Copyright (C) 2014 Giuseppe Mazzapica

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
require_once 'PageInterface.php';
require_once 'ControllerInterface.php';
require_once 'TemplateLoaderInterface.php';
require_once 'Page.php';
require_once 'Controller.php';
require_once 'TemplateLoader.php';

$controller = new Controller ( new TemplateLoader );

add_action( 'init', array( $controller, 'init' ) );

add_filter( 'do_parse_request', array( $controller, 'dispatch' ), PHP_INT_MAX, 2 );

add_action( 'loop_end', function( \WP_Query $query ) {
  if ( isset( $query->virtual_page ) && ! empty( $query->virtual_page ) ) {
    $query->virtual_page = NULL;
  }
} );

add_filter( 'the_permalink', function( $plink ) {
  global $post, $wp_query;
  if (
    $wp_query->is_page
    && isset( $wp_query->virtual_page )
    && $wp_query->virtual_page instanceof Page
    && isset( $post->is_virtual )
    && $post->is_virtual
  ) {
    $plink = home_url( $wp_query->virtual_page->getUrl() );
  }
  return $plink;
} );

Page.php

<?php
namespace GM\VirtualPages;

class Page implements PageInterface {

  private $url;
  private $title;
  private $content;
  private $template;
  private $wp_post;
  
  function __construct( $url, $title = 'Untitled', $template = 'page.php' ) {
    $this->url = filter_var( $url, FILTER_SANITIZE_URL );
    $this->setTitle( $title );
    $this->setTemplate( $template);
  }
  
  function getUrl() {
    return $this->url;
  }
  
  function getTemplate() {
    return $this->template;
  }
  
  function getTitle() {
    return $this->title;
  }
  
  function setTitle( $title ) {
    $this->title = filter_var( $title, FILTER_SANITIZE_STRING );
    return $this;
  }
  
  function setContent( $content ) {
    $this->content = $content;
    return $this;
  }
  
  function setTemplate( $template ) {
    $this->template = $template;
    return $this;
  }
  
  function asWpPost() {
    if ( is_null( $this->wp_post ) ) {
      $post = array(
        'ID'             => 0,
        'post_title'     => $this->title,
        'post_name'      => sanitize_title( $this->title ),
        'post_content'   => $this->content ? : '',
        'post_excerpt'   => '',
        'post_parent'    => 0,
        'menu_order'     => 0,
        'post_type'      => 'page',
        'post_status'    => 'publish',
        'comment_status' => 'closed',
        'ping_status'    => 'closed',
        'comment_count'  => 0,
        'post_password'  => '',
        'to_ping'        => '',
        'pinged'         => '',
        'guid'           => home_url( $this->getUrl() ),
        'post_date'      => current_time( 'mysql' ),
        'post_date_gmt'  => current_time( 'mysql', 1 ),
        'post_author'    => is_user_logged_in() ? get_current_user_id() : 0,
        'is_virtual'     => TRUE,
        'filter'         => 'raw'
      );
      $this->wp_post = new \WP_Post( (object) $post );
    }
    return $this->wp_post;
  }
}

PageInterface.php

<?php
namespace GM\VirtualPages;

interface PageInterface {

  function getUrl();
  
  function getTemplate();
  
  function getTitle();
  
  function setTitle( $title );
  
  function setContent( $content );
  
  function setTemplate( $template );
  
  /**
  * Get a WP_Post build using viryual Page object
  *
  * @return \WP_Post
  */
  function asWpPost();
}

TemplateLoader.php

<?php
namespace GM\VirtualPages;

class TemplateLoader implements TemplateLoaderInterface {

  public function init( PageInterface $page ) {
    $this->templates = wp_parse_args(
      array( 'page.php', 'index.php' ), (array) $page->getTemplate()
    );
  }
  
  public function load() {
    do_action( 'template_redirect' );
    $template = locate_template( array_filter( $this->templates ) );
    $filtered = apply_filters( 'template_include',
      apply_filters( 'virtual_page_template', $template )
    );
    if ( empty( $filtered ) || file_exists( $filtered ) ) {
      $template = $filtered;
    }
    if ( ! empty( $template ) &&file_exists( $template ) ) {
      require_once $template;
    }
  }
}

TemplateLoaderInterface.php

<?php
namespace GM\VirtualPages;

interface TemplateLoaderInterface {

  /**
  * Setup loader for a page objects
  *
  * @param \GM\VirtualPagesPageInterface $page matched virtual page
  */
  public function init( PageInterface $page );
  
  /**
  * Trigger core and custom hooks to filter templates,
  * then load the found template.
  */
  public function load();
}