Middleware no longer takes a Pipeline.

Upgrade PHPUnit to 5.6.7.

Add the Router and RouteMap components for http2.

These are similar to the UrlMap and FrontController request processor in http,
but have been adapted to the Pipeline/Middleware architecture.

Initial implementation of a new HTTP library based on pipelines.

A Pipeline is a series of chained Middleware that execute in order to produce a
response.

The goal is for the http2 subsystem to implement the same concepts as http, but
with looser coupling between the controllers and output filters.

NotFoundInterceptor needs to permit a NULL Action.

Restore FrontController::InvokeAction().

Fix views\Template accessing RootController rather than FrontController.

Introduce FrontController as the replacement for RootController.

The FrontController has no delegate, but instead uses Interceptors to allow
middleware to further process the request or to interrupt control flow.

One integral change is that if no Action is found for the Request in the UrlMap,
then no action will be taken by the FrontController. Instead, a
NotFoundInterceptor should be used to send a HTTP 404 response in this event.

Add Request::Filter and ::FilterArray.

Use filter_var() over base/filter.php, which is going away soon.

Cache templates with the full template path rather than just the name.

This allows multiple TemplateLoaders to operate on different template_paths
but with the same template_cache.

The default behavior for RestAction should be to error METHOD_NOT_ALLOWED.

In views\Template, do not use base/filter.php wrappers where it's not necessary.

Check for the presence of a RootControllerDelegate before calling it.

Do not call RootControllerDelegate through WeakInterface.

This adds too much indirection in critical codepaths.

Add RootController::StopWithRedirect() as a redirect shortcut.

Simplify WeakInterface by replacing the MethodImp with a hash.

Implement a noop views\FileCacheBackend::GetMultipleTemplates().

Implement template PreCache-ing in the TemplateLoader.

FileCacheBackend still needs to implement it, and tests need to be written.

Escape the callstack function args in ProfilingPDO::ConstructHTMLDebugBlock().

Throw an exception if the template file does not exist.

Testing the return value of PDOStatement::Execute does not appear to work on MySQL.

Pass a variable that is actually defined to MarkTemplateRendered in Template::Render.

Write a CacheBackend implementation for PDO.

Refactor builtin functions into a TemplateBuiltins class.

Also write some poor tests.

Write the initial builtin Template macro functions implementation.

Rewrite the template system to have user-customizable open and close tags.

This requires a change in the grammar to normalize it. Rather than having {% %}
print an expression, it now evaluates a statement. To print, use {%= %} instead.
{!% %} has been removed.

Print comparison failure expected and actual values.

Split TemplateLoader's cache business into another interface and class.

This creates the CacheBackend interface, which will allow for a database cache,
and one concrete implementation FileCacheBackend. This implementation implements
the existing TemplateLoader cache behavior.

Make use of Template names for usage profiling.

Add base/profiling.php and data/profiling_pdo.php.

Add a CHANGES file.

Make OutputFilter::_EncodeXML protected so that the test can access it.

Add http\Input class to provide an input sanitization system.

Change OutputFilter to use a delegate instead of subclassing to override behavior.

Implement hoplite\filter\RawString

Add a getter for the RootController delegate

Add RootController::StopWithCode()

Refactor the response type guessing in OutputFilter into a method

Fix MakeUrl() for when calling it at the root page.

Use JSON_NUMERIC_CHECK for json_encode()

Add hoplite\views\MakeURL() in a kind of hacky way.

Add hoplite\views\Inject()

Extract PUT data as POST params

Add RootController::MakeURL()

* Make Controller have an abstract _SelectModel method.
* Merge the request data for the model in FilterRequest()

Make RootControllerDelegate::OnInitialRequest also send the response

Missing a set of ()

Add functionality to OutputFilter for rendering templates

template_loader.php needs to include template.php

Allow an array of variables to be passed to Template::Render()

Merge form/request data in the Controller

Check the right header for X-Requested-With

* Catch PDOException in Controller
* Switch to setting the exception as the body rather than a data

Make sure $rule_frag has length before indexing it.

Don't return in FilterOutput() if there's a body already.

Introduce a file loader to the UrlMap.

Special case the empty rule.

Only check the Request#data[format] key if it is set

Send the HTTP status code in the response

Assume an empty PATH_INFO is the root URL.

Fix more bugs in TemplateLoader and a singleton helper

.gitignore broke the test!

Get TemplateLoader working and update the tests

Change Template::Render to return the result, rather than print it.

Add RootControllerDelegate

Set null_allowed to TRUE by default.

More optimizations by caching the value of IsRequired()

Speed up WeakInterface by 2x by caching the object reflector.

Create WeakInterface

Implement OutputFilter::_CreateBodyForResponse()

Add OutputFilter::_EncodeXML and create a test

Naïve implementation of RootController::LookupAction

* Add RestAdapaterTest
* Refactor common HTTP test fixtures out into a new file

All tests pass again

Add http\RestAdapter

Make http\RestController's Do methods public

Add data\Controller

Add data\Model from phalanx

Add base\Struct from phalanx

Fix a bug in TemplateLoader

Add WIP TemplateLoader

* Get the correct column number in parsing exceptions
* Throw an exception when nesting two macros

Add basic template parser and test

Implement UrlMap::LookupAction()

Update RootController and test so that a Request is passed to UrlMap::Evaluate()

Implement UrlMap::Evaluate() with all its tests passing.

Don't print OK if a test fails

* Add a set of failing tests for UrlMap -- TDD!
* Document how strict pattern matching works (versus prefix)

Add ActionControllerTest

Add a test for RestAction

* Write a unittest for RootControler
* Fix a bunch of syntax errors

Add unit testing infrastructure, again straignt from phalanx

Add functions.php, copied from phalanx

Stub out the OutputFilter

Stub out UrlMap

* Add ActionController
* Split out ResponseCode into its own file

Whitespace nits in the README

Add the Request and Response objects copied from phalanx

Start stubbing out the design doc interfaces