Bumped version up to 0.1.0.24.
Added Input & Output interfaces. Put them into the Macaroni::Environment namespace which is a mistake, they should get moved to Macaroni::IO soon.
Began work on an advanced mode which will interpret all Lua scripts free of context as a way of getting rid of the awful complexity and nastiness of the current manifest files. My first step is to create a simple Environment class with a REPL and then add Lua glue'd classes to it as needed.
Added Group, GroupList, and Utils class to Macaroni::Model::Project.
Changed spacing in some other files.
The Macaroni Project system can now be used to parse a Library of Macaroni Code

I have been so busy for the past several months I haven't been able to check in my progress.
Its also affected my focus, which means each time I pick up Macaroni I work on something random, and some features get half-written, don't work, and now are being checked-in this way. Sorry.

* Switched Context, FileSet, Parser, ParserException classes into Mcpp file.
* Added WorkingDirectory property to AppPaths.
* Sublime text trimmed the whitespace on some files.
* Added a REPL mode to the CmdLine class.
* Changed how the CmdLine class works to support the new project system.
* Added ability to specify a different location of the Message file in the CmdLine class.
* The Environment class now opens all Lua modules on start up, so now require statements are needed.
* The Environment class also puts the context and output objects into global variables for ease of use.
* The Environment class now has commands that can be entered into the REPL, prefixed with "~". All of these are class methods marked with special annotations. A Lua plugin parses them and writes the method to dispatch to each one, and also a help function which lists them and their usage.
* Changed the Messages class to be optionally initialized from a different path. This class is still a complete mess though.
* Did some work to make Classes, Scope and other Elements in NodeSpace accept a Target instead of a Library, since Targets are the future.
* Gave Scope an "OwnedBy" method, which Lua plugins can query to see if a Node Member is owned by some Target.
* Changed the PippyParser class to accept a Target as well as a Library.
* Added to the Project and ProjectVersion class substantially (don't know if it was this or prior commit).
* Added a Target class. Targets attach to ProjectVersions.
* Added a LibraryTarget class which is a Target. This is a long-term replacement for a Macaroni Library, which is specialized form of Target. Since Target replaces the old Library, this is what will be used by most projects instead.
* Made some changes to the Macaroni.rc file so I could make Macaroni compile with VC++10.
* Made some minor changes to several generators. The Sublime whitespace trimming makes it hard to see what... sorry.
* The LuaGlue generator can now accept an annotation with source code to use to wrap a function. This is useful if the C++ function would otherwise be too difficult to wrap, or something special needs to happen (such as reading from an argument table).
* Creating a Lua plugin to generate VC++10 Express project files from a given Macaroni library.
* Added some notes about possible Tests in Macaroni Nodespace in the future.
Rewrote the VS2008 project creator plugin to work (though it currently has a very focused feature set, hyork). Fixed an issue with startup so now if project.lua isn't found the old manifest system is used.
Preliminary work on putting plugins in the Project system.
Random work done on Netbook.
Continued work on the new Project build system and related areas.

Exception Handling
* Changed Macaroni::Exception to not always store a std::string but have a "message" property which returns a string that can be created on command. Created a subclass which stores a std::string that all the old code uses; the hope is to migrate away from this practice.
* Created a class Macaroni::InternalSource which is just a short hand for the file name and line numbers. A Macro MACARONI_INTERNAL_SOURCE fetches these.
* Created some subclasses of Macaroni::Exception with Macros to easily be able to define new exceptions that have only one message.

Created a way to store Lua table values.
* This was complicated but turned out to be invaluable in moving Lua tables between independent Lua states or C++ functions.

Plugins now work in the new project system!
* This was due to the marshalling ability. Plugins get called in a more general way and actual Lua data is passed, instead of executing parsed code snippets (which is how the manifest system called them).
* I made the Target class emulate the Library class, so a *simple* pass through the Cpp plugin's Generate method works.

Advanced the new "Project" build system.
* Added a Files class to store lists of files.
* Added an Artifact class.
* Added a Config class to store Boost Build feature type info.

Cpp Plugin
* Prevented nested classes whose hfiles where defined from being generated (this had been a bug).
* Used long name for nested classes in CPP files to avoid issues (really a kludge rather than a fix).
* Rather than checking the library, instead call the OwnedBy method in spots which is more general.
* Prevent using statement generation for nested class (this was a bug).

Lue Glue Plugin
* Added ability to add normal C++ code to index method of Lua Glue in annotation.
* Added ability to override setter in the same way.
Continuing work on the Project system. The end may be in sight.
* FileSet renamed to RegexFileSet. FileSet interface slightly simplified to allow for different kind of file sets.
* FileName now needs a Path and not just a string. Paths seemed to be used everywhere, its honestly a huge mess I can't seem to sort out and may only be getting worse.
* FileName also has a "CreateNonPhysical" static method to be used when the file path isn't real. This will probably be more and more important.
* Added some functions to the Path class.
* Decided to open all Lua modules from within every Lua plugin. Why not?
* Worked on loading projects, executing the Lua code for them. This enables dependencies in the project system.
* Added Error methods to the Output class as a generalized way of outputting errors.
* Made PathList static methods accessible in Lua, created Environment::Value marshallers.
* Fixed a bug in SimpleStringException.
* Added some kind of memory bug that occurs when shutting down the program. Have fun dealing with that, future-me.
* Added the FindProjectVersion to the Context class.
* Added methods to get and set which Target owns elements. Element now has GetOwner in addition to OwnedBy.
* Element now has a SwitchOwner so the target an Element is owned by can be switched to a different one, but only if its from the same ProjectVersion.
* Added a "UnitTarget" then spent two days figuring out what I'd thought would be a simple matter of plugging it in. Its nowhere near that simple of course. At first I thought the Parser should make new UnitTargets for major Elements such as classes, but turns out it can't be that static because sometimes where an Element will live isn't known until after parsing is finished (for instance ~hfile complicates this).
* Created a "Porg" plugin for Physical Organization. This handles creating Unit targets in a library for major classes before handing work over to the Cpp plugin.
* Added an equals of operator to Node, Element, and Path classes.
* Added method IsMatch on Config to make lists of them easier to loop over.
* Added lists of Paths to Library, but after mucking with UnitTarget, I think I may ultimately delete them.
* An important point: UnitTarget, and smaller, more granular Targets like it, could replace the idea of attaching lists of files (aka "Artifacts") to every target. Making specific Targets will be more difficult but could ultimately be more correct.
* Targets now have a list of Elements attached to them. This way Lua code can quickly iterate all Elements assigned to a target.
* When TargetFileSweeper encounters non-generated C++ files (.cpp) it automatically creates a UnitTarget for them.
* Created a light-weight TargetList class to be used from Lua, i.e. you can now pull a "Dependencies" property from a Target in Lua code.
* Started work on Boost Build v2 plugin which will use the Project system.
* Created Boost-header pre-installed library which the new Project system can use, that doesn't need to update a bjam file like the old one.
* I also stopped using the "cloned" Library directory, since I'm going to quite using the on-demand bjam files for installed dependencies.
Tried to make targets get generated instead of directly creating files.

* After targets are created, the files will be made from them.
* Added Output to the Values serialization stuff.
* Added operator!= to Macaroni::IO::Path.
* Added "RequiresCppFile" to Element.
* Changed GetName() accessor of FileName. Not sure why because I go weeks between updating this project. :(
* Made Target work with Lua operator =.
* Changed Lua generator to enable custom code for exception translations.
* Made Target.SetCppFile stuff work in Lua.
* Changed Lua generation of Macaroni so exceptions will be caught and translated correctly.
BoostBuild2 generator now can generate a project with multiple exes and one library.

* Fixed bug in CustomValues.cpp where ProjectVersion wasn't being marshalled.
* Added an "ExeTarget."
* Gave ProjectVersion a "Targets" property and fixed bug where Libraries created from Lua didn't have all the dependencies given to them.
* Added a "TypeName" to Target, which is necessary since now plugins are dealing with unit, lib and exe types.
* Had to add a way to set the "root" directory of the Cpp and Hpp files on a UnitTarget, since one plugin creates them in a general sense and another actually writes them out.
* The PippyParser now has a "~type" option for ~units, which is how exes work.
* Drastically changed the BoostBuild2 plugin to generate on a whole project basis and not a Target basis.
* Changed a bit of the Cpp / Porg / UnitFileGenerator stuff.
* UnitFileGenerator now works for classes, but nothing else. Shouldn't be hard to add the old stuff.
Boost Test targets can now be generated.

* No longer go into REPL mode unless it specified.
* The command line options "clean", "generate", "build", and "install" no call global functions with those names specified in the project lua file.
* Added a "findInstallPath" and "findOrCreateInstallPath" argument to the global functions available in Lua.
* Added property "RequiresHFile" to the Element class and subclasses.
* Changed ExeTarget to include a "SubType" property, which can be "test" in order to add test targets.
* Made the exception thrown when a ProjectVersion has a target with the same named added twice a bit easier to understand.
* Added a clearer exception when a file sweeper cannot read a file due to the relative path being wrong.
* Added the ability to add an Exe or Test to the Lua glue for Target.
* BoostBuild2 plugin now generates unit test targets, as does Cpp plugin.
* UnitFileGenerator now works for typedefs too.
* Porg generates ".h" files instead of ".hpp". One day I'll change it to ".hpp" but not today. :(
Copying missing files.
Targets built by Boost can be "installed" and referenced from elsewhere.

* Invented a method called "sinstall" (for speedy install, or sloppy install, or other words starting with "s") to get out of the work it was taking to do this. I'll figure out the real way later, for now I'm getting real results at the expense of disk space. Yippee!
* Had extreme difficulty building in Windows 8, so made a jamroot.jam file to build the thing and batch file called "QuickBuild.bat."
* Updated code to use Boost version 1.49.
* Had to update cavatappi.bat too due to weird build problems... this was really and hard to deal with since I was changing machines.
* Changed the JamGenerator (used for the Macaroni project itself) a bit.
* A "Block" can now extend to the end of the file. This allows for mcpp files that just contain plain C files preceded by ~import statements.
* Block now has a RequiresCppFile, GetOwner, GetImportedNodes and other fun methods used by Elements such as Class.
* Created a NakedNodeList. It's like NodeList but uses dumb pointers.
* Cleaned up some exception messages.
* Added a ton of code to the BoostBuild2 plugin to where its no semi-functional and usable on tiny projects.
* Added an "Install" method to some plugins... but nothing is useful. Guess I'm just checking in cruft. :(
* Added "IterateDependencyProjects" method to Plugin Lua module.
* Got the Features/BoostBuild set of test projects working with the new project system (though all three don't automatically build from a list of children like before). It works pretty much equivalently now, but I added some extra EXE projects to the two libs just to make things interesting. Adding those also made the functionality easier to reinstate.
* Fixed up the UnitTarget project a bit.
Updated tests to use new build system, fixed issues along the way.

* Corrected behavior of cmdline runner.
* Due to Boost Build limit on metatargets, had to generate hash codes for
  most targets.
* Added short library names, since Windows has a 200-something limit. The
  dream of globally unique dll names is deader than a dead dollar bill.
* Took a bunch of junk out of Environment.mcpp to create the ProjectLoader
  and ProjectEnvironment class. Hopefully this is clearer.
* Took junk out of Context class and put it into the ProjectLoader class.
* Added a "~hidden public" access type, because really, the goal of this
  project is to make people's brains bleed.
* Fixed a bug in Group FindOrCreate.
* Added some more one off fun stuff to the Path class.
* Added a Resource target. This way I can associate stuff like Lua scripts
  to a target and then not worry about where it lives.
* Fixed block generator.
* Changed AccessType tests to fit into new character limits.
* Gave all Features tests "project.lua" files to sit next to the old
  manifest files.
* Added a SimpleProject lua script. This adds Maven like build
  specification to the new project system. It blew my mind how simple this
  was- took maybe an hour or so. It also works for nested projects thanks
  to the refactoring of the Environment class!
* Redid the Lua project inside the Dependencies directory. I think its
  still backwards compatable with Macaroni version 0.1.0.23 by should
  work on the new stuff too.
Updated code to support MinGW.
Fixed up the release project, so the site generates again.

* Added "findInstallPath" function to plugins.
* Added "findProjectVersion".
* Changed how blocks which read all files look - they now look for the
  syntax ":=".
* Added "()" to the list of overloadable operators.
* The ~unit keyword no longer needs tilde for options such as "hfile",
  "cppfile" and "type".
* Fixed up the release project to use the new project system.
Allows blocks at the top and bottom of class files.

* Adds "top" and "bottom" block IDs, which can be used by classes.

* Added a block document explaining blocks and which IDs are used.

* Added a template and macro example.

* Changed the CSS a bit.
Started Vagrant file.

Changed colors of generated site.
More progress on Ubuntu version.

* Rewrote Paths class.
* Replaced usage of boost::filesystem::system_complete with canonical
  as this seems to work on both OSes.
* Fixed a goofy bug in Node::SplitComplexName.
* Changed Lua tests to work again. They hadn't been run in a long time,
  and the Lua glue changed. There's a new bug which keeps the Parser
  from throwing exceptions correctly in Lua. :(
* Fixed minor bugs in definitions of some dependencies.
* Updated Ubuntu build script.
Fixed a deprecate Lua test.

* Changed QuickBuild-Gcc.bat to not refer to directories on my machine.