Config file formatting, remove logger from CD for now as it was throwing errors

currentContext doesnt contain umbraco-route-def

.hgtags

@@ -27,5 +27,9 @@ ff3bb24ea0c915878396a6ae27f1ff164e8ac150 Release-6.0.0-beta
 1719fbd857f28b376639ac2aa0abada0ef2e7560 Release-6.0.0
 e02f5aebb87e3f07d27376647756caa9762931d8 Release-4.11.4
 14338b0ab1738fbd8987677ecdb9a73d79fc229d release-4.11.6
+ce47176bc6b9298741783e20f1fe2672c811f744 release-4.11.7
 b247b35d821144849f551e02da8ba719f91d5fb0 Release-6.0.2
 aed55cba29009ad3db48880a7cfb66407ce9805f release-6.0.3
+87cf618a39e38ec58df916d10e6a924de62ae37d release-6.1.0-beta
+0dee9964687ea51ea797984cf7cce3655d6a6558 release-6.0.4
+7670bb47a671a9ecc15118589d8048907ea76241 release-6.1.0-beta2

build/Build.bat

@@ -1,6 +1,6 @@
 @ECHO OFF
 SET release=6.1.0
-SET comment=beta
+SET comment=
 SET version=%release%
 
 IF [%comment%] EQU [] (SET version=%release%) ELSE (SET version=%release%-%comment%)

build/NuSpecs/UmbracoCms.Core.nuspec

@@ -18,6 +18,7 @@
             <dependency id="Microsoft.AspNet.Mvc" version="[4.0.20710.0]" />
 			<dependency id="Microsoft.AspNet.WebApi" version="4.0.20710.0" />
 			<dependency id="Microsoft.AspNet.Mvc.FixedDisplayModes" version="1.0.0" />
+			<dependency id="MiniProfiler" version="2.1.0" />
         </dependencies>
     </metadata>
 	<files>
@@ -63,8 +64,6 @@
 		<file src="..\_BuildOutput\WebApp\bin\umbraco.providers.dll" target="lib\umbraco.providers.dll" />
 		<file src="..\_BuildOutput\WebApp\bin\umbraco.providers.xml" target="lib\umbraco.providers.xml" />
 		<file src="..\_BuildOutput\WebApp\bin\Umbraco.Web.UI.dll" target="lib\Umbraco.Web.UI.dll" />
-		<file src="..\_BuildOutput\WebApp\bin\umbraco.webservices.dll" target="lib\umbraco.webservices.dll" />
-		<file src="..\_BuildOutput\WebApp\bin\umbraco.webservices.xml" target="lib\umbraco.webservices.xml" />
 		<file src="..\_BuildOutput\WebApp\bin\umbraco.XmlSerializers.dll" target="lib\umbraco.XmlSerializers.dll" />
 		<file src="..\_BuildOutput\WebApp\bin\UmbracoExamine.dll" target="lib\UmbracoExamine.dll" />
 		<file src="..\_BuildOutput\WebApp\bin\UrlRewritingNet.UrlRewriter.dll" target="lib\UrlRewritingNet.UrlRewriter.dll" />

build/RevertToEmptyInstall.bat

@@ -0,0 +1,161 @@
+@ECHO OFF
+
+:choice
+set /P c=WARNING! Are you sure you want to continue, this will remove all package files, view files, sqlce database, etc... Press 'Y' to auto-remove all files/folders, 'N' to cancel or 'C' to prompt for each folder removal?
+if /I "%c%" EQU "C" goto :prompt
+if /I "%c%" EQU "Y" goto :auto
+if /I "%c%" EQU "N" goto :exit
+goto :choice
+
+
+:prompt
+
+echo Current folder: %CD%
+
+echo Regenerating SQL CE database
+SET buildfolder=%CD%
+CD ..\tools\RegenerateUmbracoSQLCEDatabase\
+RegenerateUmbracoSQLCEDatabase.exe %CD%\..\..\src\Umbraco.Web.UI
+CD %buildfolder%
+
+echo Removing bin files
+del ..\src\Umbraco.Web.UI\bin\*.*
+
+echo Building solution
+%windir%\Microsoft.NET\Framework\v4.0.30319\msbuild.exe ..\src\umbraco.sln /t:Clean,Build
+
+echo Resetting installedPackages.config
+echo ^<?xml version="1.0" encoding="utf-8"?^>^<packages^>^</packages^> >..\src\Umbraco.Web.UI\App_Data\packages\installed\installedPackages.config
+
+echo Removing plugin cache files
+del ..\src\Umbraco.Web.UI\App_Data\TEMP\PluginCache\*.*
+
+echo Removing cache files and examine index
+del ..\src\Umbraco.Web.UI\App_Data\TEMP\*.*
+
+echo Removing log files
+del ..\src\Umbraco.Web.UI\App_Data\Logs\*.*
+
+echo Removing packages
+del ..\src\Umbraco.Web.UI\App_Data\packages\*.*
+
+echo Removing previews
+del ..\src\Umbraco.Web.UI\App_Data\preview\*.*
+
+echo Removing app code files (typically added by starterkits)
+del ..\src\Umbraco.Web.UI\App_Code\*.*
+
+echo Removing xslt files
+del ..\src\Umbraco.Web.UI\xslt\*.*
+
+echo Removing user control files
+del ..\src\Umbraco.Web.UI\UserControls\*.*
+
+echo Removing masterpage files
+del ..\src\Umbraco.Web.UI\masterpages\*.*
+
+echo Removing view files
+del ..\src\Umbraco.Web.UI\Views\*.*
+
+echo Removing razor files
+del ..\src\Umbraco.Web.UI\macroScripts\*.*
+
+echo Removing media files
+del ..\src\Umbraco.Web.UI\media\*.*
+
+echo Removing script files
+del ..\src\Umbraco.Web.UI\scripts\*.*
+
+echo Removing css files
+del ..\src\Umbraco.Web.UI\css\*.*
+
+echo "Umbraco install reverted to clean install"
+pause 
+exit
+
+
+
+:auto
+
+echo Current folder: %CD%
+
+echo Regenerating SQL CE database
+SET buildfolder=%CD%
+CD ..\tools\RegenerateUmbracoSQLCEDatabase\
+RegenerateUmbracoSQLCEDatabase.exe %CD%\..\..\src\Umbraco.Web.UI
+CD %buildfolder%
+
+echo Removing bin files
+ FOR %%A IN (..\src\Umbraco.Web.UI\bin\*.*) DO DEL %%A
+
+echo Building solution
+%windir%\Microsoft.NET\Framework\v4.0.30319\msbuild.exe ..\src\umbraco.sln /t:Clean,Build
+
+echo Resetting installedPackages.config
+echo ^<?xml version="1.0" encoding="utf-8"?^>^<packages^>^</packages^> >..\src\Umbraco.Web.UI\App_Data\packages\installed\installedPackages.config
+
+echo Removing plugin cache files
+FOR %%A IN (..\src\Umbraco.Web.UI\App_Data\TEMP\PluginCache\*.*) DO DEL %%A
+
+echo Removing cache files and examine index
+FOR %%A IN (..\src\Umbraco.Web.UI\App_Data\TEMP\*.*) DO DEL %%A
+
+echo Removing log files
+FOR %%A IN (..\src\Umbraco.Web.UI\App_Data\Logs\*.*) DO DEL %%A
+
+echo Removing packages
+FOR %%A IN (..\src\Umbraco.Web.UI\App_Data\packages\*.*) DO DEL %%A
+
+echo Removing previews
+FOR %%A IN (..\src\Umbraco.Web.UI\App_Data\preview\*.*) DO DEL %%A
+
+echo Removing app code files (typically added by starterkits)
+FOR %%A IN (..\src\Umbraco.Web.UI\App_Code\*.*) DO DEL %%A
+
+echo Removing xslt files
+FOR %%A IN (..\src\Umbraco.Web.UI\xslt\*.*) DO DEL %%A
+
+echo Removing masterpage files
+FOR %%A IN (..\src\Umbraco.Web.UI\masterpages\*.*) DO DEL %%A
+
+echo Removing user control files
+FOR %%A IN (..\src\Umbraco.Web.UI\usercontrols\*.*) DO DEL %%A
+
+echo Removing view files
+FOR %%A IN (..\src\Umbraco.Web.UI\Views\*.*) DO DEL %%A
+
+echo Removing razor files
+FOR %%A IN (..\src\Umbraco.Web.UI\macroScripts\*.*) DO DEL %%A
+
+echo Removing media files
+FOR %%A IN (..\src\Umbraco.Web.UI\media\*.*) DO DEL %%A
+
+echo Removing script files
+FOR %%A IN (..\src\Umbraco.Web.UI\scripts\*.*) DO DEL %%A
+
+echo Removing css files
+FOR %%A IN (..\src\Umbraco.Web.UI\css\*.*) DO DEL %%A
+
+echo Removing Courier files
+del ..\src\Umbraco.Web.UI\config\courier.config
+del ..\src\Umbraco.Web.UI\umbraco\images\tray\courier.jpg
+rmdir "..\src\Umbraco.Web.UI\umbraco\plugins\courier\" /S /Q
+
+echo Removing Contour files
+del ..\src\Umbraco.Web.UI\umbraco\images\tray\contour.png
+FOR %%A IN (..\src\Umbraco.Web.UI\umbraco\images\umbraco\icon_*.*) DO DEL %%A
+rmdir "..\src\Umbraco.Web.UI\umbraco\plugins\umbracoContour\" /S /Q
+del ..\src\Umbraco.Web.UI\umbraco\xslt\templates\UmbracoContour*.* /S /Q
+rmdir "..\src\Umbraco.Web.UI\usercontrols\umbracoContour\" /S /Q
+
+echo Start with a clean web.config
+copy ..\src\Umbraco.Web.UI\web.Template.config ..\src\Umbraco.Web.UI\web.config /Y
+
+echo "Umbraco install reverted to clean install"
+pause 
+exit
+
+
+
+:exit
+exit

docs/GettingStarted.txt

@@ -1,24 +0,0 @@
-Hi! Thanks for grabbing the Umbraco sourcecode.
-
-===========================================
-NOTE - DEFAULT BRANCH EMPTY - December 2010
-===========================================
-
-
-- With the help of CodePlex we have migrated much of our previous changesets (as of Dec 13th 2010) from TFS to Mercurial.
-
-- However, not everything could be migrated to our new branching workflow. So for each nominal group of 4.x changes, we've created named branches. For upcoming 5.x changesets, we'll adhere to our new workflow which we'll describe on the Wiki for contributors.
-
-- FOR THE MOMENT, the 'default' branch is empty - pending the addition of the 5.0 changesets
-
-- To switch to the codebase on which you want to work, 'hg update' to the named branch (e.g. "4.6.0") or tag (e.g. "Release-4.5.2") and browse or work from that point.
-
-
-Thanks to Matt Hawley at CodePlex for his help in our migration!
-
-Cheers,
-The Umbraco Team
-
-http://umbraco.org
-http://our.umbraco.org
-http://umbraco.codeplex.com

docs/IronPython License.Rtf

@@ -1,82 +0,0 @@
-{\rtf1\ansi\ansicpg1252\uc1\deff0\stshfdbch0\stshfloch0\stshfhich0\stshfbi0\deflang1033\deflangfe1033{\fonttbl{\f0\froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f36\fswiss\fcharset0\fprq2{\*\panose 020b0604030504040204}Tahoma;}
-{\f39\froman\fcharset238\fprq2 Times New Roman CE;}{\f40\froman\fcharset204\fprq2 Times New Roman Cyr;}{\f42\froman\fcharset161\fprq2 Times New Roman Greek;}{\f43\froman\fcharset162\fprq2 Times New Roman Tur;}
-{\f44\froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\f45\froman\fcharset178\fprq2 Times New Roman (Arabic);}{\f46\froman\fcharset186\fprq2 Times New Roman Baltic;}{\f47\froman\fcharset163\fprq2 Times New Roman (Vietnamese);}
-{\f399\fswiss\fcharset238\fprq2 Tahoma CE;}{\f400\fswiss\fcharset204\fprq2 Tahoma Cyr;}{\f402\fswiss\fcharset161\fprq2 Tahoma Greek;}{\f403\fswiss\fcharset162\fprq2 Tahoma Tur;}{\f404\fswiss\fcharset177\fprq2 Tahoma (Hebrew);}
-{\f405\fswiss\fcharset178\fprq2 Tahoma (Arabic);}{\f406\fswiss\fcharset186\fprq2 Tahoma Baltic;}{\f407\fswiss\fcharset163\fprq2 Tahoma (Vietnamese);}{\f408\fswiss\fcharset222\fprq2 Tahoma (Thai);}}{\colortbl;\red0\green0\blue0;\red0\green0\blue255;
-\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0;
-\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;}{\stylesheet{\ql \li0\ri0\widctlpar\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \snext0 Normal;}{\*\cs10 \additive 
-\ssemihidden Default Paragraph Font;}{\*\ts11\tsrowd\trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\trcbpat1\trcfpat1\tscellwidthfts0\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv 
-\ql \li0\ri0\widctlpar\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \fs20\lang1024\langfe1024\cgrid\langnp1024\langfenp1024 \snext11 \ssemihidden Normal Table;}{\s15\ql \li0\ri0\widctlpar\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 
-\f36\fs16\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext15 \ssemihidden \styrsid668380 Balloon Text;}}{\*\latentstyles\lsdstimax156\lsdlockeddef0}{\*\listtable{\list\listtemplateid130696116{\listlevel\levelnfc0\levelnfcn0\leveljc0
-\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'02\'00.;}{\levelnumbers\'01;}\fi-360\li720\jclisttab\tx720\lin720 }{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0
-{\leveltext\'02\'01.;}{\levelnumbers\'01;}\fi-360\li1440\jclisttab\tx1440\lin1440 }{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'02\'02.;}{\levelnumbers\'01;}\fi-360\li2160
-\jclisttab\tx2160\lin2160 }{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'02\'03.;}{\levelnumbers\'01;}\fi-360\li2880\jclisttab\tx2880\lin2880 }{\listlevel\levelnfc0\levelnfcn0\leveljc0
-\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'02\'04.;}{\levelnumbers\'01;}\fi-360\li3600\jclisttab\tx3600\lin3600 }{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0
-{\leveltext\'02\'05.;}{\levelnumbers\'01;}\fi-360\li4320\jclisttab\tx4320\lin4320 }{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'02\'06.;}{\levelnumbers\'01;}\fi-360\li5040
-\jclisttab\tx5040\lin5040 }{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'02\'07.;}{\levelnumbers\'01;}\fi-360\li5760\jclisttab\tx5760\lin5760 }{\listlevel\levelnfc0\levelnfcn0\leveljc0
-\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'02\'08.;}{\levelnumbers\'01;}\fi-360\li6480\jclisttab\tx6480\lin6480 }{\listname ;}\listid723138990}}{\*\listoverridetable{\listoverride\listid723138990\listoverridecount0\ls1}}
-{\*\pgptbl {\pgp\ipgp2\itap0\li0\ri0\sb0\sa0}{\pgp\ipgp0\itap0\li0\ri0\sb0\sa0}{\pgp\ipgp4\itap0\li0\ri0\sb0\sa0}{\pgp\ipgp0\itap0\li0\ri0\sb0\sa0}{\pgp\ipgp0\itap0\li0\ri0\sb0\sa0}}{\*\rsidtbl \rsid288726\rsid668380\rsid1077358\rsid1250157\rsid1778664
-\rsid2232581\rsid3018318\rsid3766585\rsid4417501\rsid4531485\rsid4807452\rsid5341002\rsid7018004\rsid7880391\rsid10749719\rsid12150908\rsid12939982\rsid13596669\rsid15149892\rsid15551579\rsid16128754\rsid16674677}{\*\generator Microsoft Word 11.0.6359;}
-{\info{\title Shared Source License for Software included in Workspaces}{\author suev}{\operator Martin Maly}{\creatim\yr2005\mo3\dy22\hr10\min45}{\revtim\yr2005\mo3\dy22\hr15\min54}{\printim\yr2002\mo9\dy20\hr15\min39}{\version3}{\edmins1}{\nofpages1}
-{\nofwords672}{\nofchars3837}{\*\company Microsoft}{\nofcharsws4501}{\vern24703}}\widowctrl\ftnbj\aenddoc\noxlattoyen\expshrtn\noultrlspc\dntblnsbdb\nospaceforul\hyphcaps0\formshade\horzdoc\dgmargin\dghspace180\dgvspace180\dghorigin1701\dgvorigin1984
-\dghshow1\dgvshow1\jexpand\viewkind5\viewscale100\pgbrdrhead\pgbrdrfoot\splytwnine\ftnlytwnine\htmautsp\nolnhtadjtbl\useltbaln\alntblind\lytcalctblwd\lyttblrtgr\lnbrkrule\nobrkwrptbl\snaptogridincell\allowfieldendsel\wrppunct
-\asianbrkrule\nojkernpunct\rsidroot15149892 \fet0\sectd \linex0\endnhere\sectlinegrid360\sectdefaultcl\sftnbj {\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl2\pnucltr\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl3
-\pndec\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta )}}{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl6\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}
-{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl8\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl9\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}\pard\plain 
-\ql \li0\ri0\widctlpar\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\b\fs28\insrsid1250157\charrsid1250157 Shared Source License for }{\b\fs28\insrsid16674677 IronPython}{
-\b\fs28\insrsid1250157 
-\par }{\b\fs28\insrsid5341002 
-\par }{\b\insrsid5341002\charrsid5341002 This license governs use of the accompanying software}{\b\insrsid5341002  (\'93Software\'94)}{\b\insrsid5341002\charrsid5341002 , and your use of the }{\b\insrsid5341002 S}{\b\insrsid5341002\charrsid5341002 
-oftware constitutes acceptance of this license.
-\par }{\insrsid1250157\charrsid5341002 
-\par }{\b\insrsid1250157\charrsid1250157 You }{\b\insrsid5341002 may}{\b\insrsid1250157\charrsid1250157  use }{\b\insrsid5341002 the}{\b\insrsid1250157\charrsid1250157  Software for any }{\b\insrsid1250157 commercial or }{\b\insrsid1250157\charrsid1250157 
-noncommercial purpose, including distributing derivative}{\b\insrsid4417501  work}{\b\insrsid1250157\charrsid1250157 s}{\b\insrsid1250157 .
-\par }{\insrsid1250157 
-\par }\pard \ql \li0\ri0\widctlpar\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid1250157 {\insrsid1250157\charrsid1250157 In return, we simply require that you agree:
-\par {\listtext\pard\plain\insrsid1250157\charrsid1250157 \hich\af0\dbch\af0\loch\f0 1.\tab}}\pard \ql \fi-360\li720\ri0\widctlpar\jclisttab\tx720\aspalpha\aspnum\faauto\ls1\adjustright\rin0\lin720\itap0\pararsid1250157 {\insrsid1250157\charrsid1250157 
-Not to remove any copyright}{\insrsid5341002  or other}{\insrsid1250157\charrsid1250157  notices from the Software. 
-\par {\listtext\pard\plain\insrsid1250157\charrsid1250157 \hich\af0\dbch\af0\loch\f0 2.\tab}That if you distribute the Software in source code form you do so only under this }{\insrsid5341002 l}{\insrsid1250157\charrsid1250157 
-icense (i.e. you must include a complete copy of this }{\insrsid5341002 l}{\insrsid1250157\charrsid1250157 icense with your distribution), and if you distribute the Software solely in object form you only do so under a license that complies with this }{
-\insrsid5341002 l}{\insrsid1250157\charrsid1250157 icense. 
-\par {\listtext\pard\plain\b\insrsid1250157\charrsid1250157 \hich\af0\dbch\af0\loch\f0 3.\tab}}{\b\insrsid1250157\charrsid1250157 
-That the Software comes "as is", with no warranties. None whatsoever. This means no express, implied or statutory warranty, including without limitation, warranties of merchantability or fitness for a particular purpose or any warranty of }{
-\b\insrsid5341002 title or }{\b\insrsid1250157\charrsid1250157 non}{\b\insrsid5341002 -}{\b\insrsid1250157\charrsid1250157 infringement. Also, you must pass this disclaimer on whenever you distribute the Software}{\b\insrsid5341002  or derivative works}{
-\b\insrsid1250157\charrsid1250157 .}{\insrsid1250157\charrsid1250157  
-\par {\listtext\pard\plain\b\insrsid1250157\charrsid1250157 \hich\af0\dbch\af0\loch\f0 4.\tab}}{\b\insrsid1250157\charrsid1250157 That neither Microsoft nor }{\b\insrsid1250157 any contributor to the Software}{\b\insrsid1250157\charrsid1250157 
- will be liable for any of those types of damages known as}{\b\insrsid5341002  }{\b\insrsid1250157\charrsid1250157 indirect, special, consequential, or incidental related to the Software or this }{\b\insrsid5341002 l}{\b\insrsid1250157\charrsid1250157 
-icense, to the maximum extent the law permits, no matter what legal theory it\rquote s based on. Also, you must pass this limitation of liability on whenever you distribute the Software}{\b\insrsid5341002  or derivative works}{
-\b\insrsid1250157\charrsid1250157 .}{\insrsid1250157\charrsid1250157  
-\par {\listtext\pard\plain\insrsid1250157\charrsid1250157 \hich\af0\dbch\af0\loch\f0 5.\tab}That if you sue anyone over patents that you think may apply to the Software for a person's use of the Software, your license to the Software ends automatically. 
-
-\par {\listtext\pard\plain\insrsid1250157 \hich\af0\dbch\af0\loch\f0 6.\tab}}{\insrsid1250157 That the patent rights, if any, }{\insrsid288726 granted in this license}{\insrsid1250157\charrsid1250157  only apply to the Software, not to any derivative}{
-\insrsid4417501  work}{\insrsid1250157\charrsid1250157 s you make.}{\insrsid3018318 
-\par {\listtext\pard\plain\insrsid3018318\charrsid3018318 \hich\af0\dbch\af0\loch\f0 7.\tab}}{\insrsid3018318\charrsid3018318 That if you are an agency of the U.S. Government, (i) Software provided pursuant to a solicitation issued on or after Dece
-mber 1, 1995, is provided with the commercial license rights set forth in this license, and (ii) Software provided pursuant to a solicitation issued prior to December 1, 1995, is provided with \'93Restricted Rights\'94
- as set forth in FAR, 48 C.F.R. 52.227-14 (June 1987) or DFAR, 48 C.F.R. 252.227-7013 (Oct 1988), as applicable.}{\insrsid1250157 
-\par {\listtext\pard\plain\insrsid1250157 \hich\af0\dbch\af0\loch\f0 8.\tab}That your rights under this License end automatically if you breach it in any way.
-\par {\listtext\pard\plain\insrsid5341002 \hich\af0\dbch\af0\loch\f0 9.\tab}}{\insrsid5341002 That all rights not expressly granted to you in this license are reserved.
-\par }\pard \ql \li0\ri0\widctlpar\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid1778664 {\insrsid1778664 
-\par }{\insrsid12150908 Read below}{\insrsid1778664  for answers to frequently asked questions about this license.
-\par }{\insrsid12150908 
-\par }\pard \ql \li0\ri0\widctlpar\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid12150908 {\b\insrsid12150908\charrsid12150908 Q: Is this license OSI compliant?
-\par }{\insrsid12150908 
-A: This license has not been submitted to OSI, but it allows developers to take full advantage of a dynamic language on the CLR and to have the freedom to distribute their works for the benefit of the community at large. The license is half of a 
-page long and very straight forward. We believe it stands up to what developers demand of an "open" license.
-\par 
-\par }{\b\insrsid12150908\charrsid12150908 Q: What copyright rights does the license grant me?
-\par }{\insrsid12150908 A: The license grants you a copyright license to make unlimited copies of the Software in sour
-ce or object code form, as well as to create Derivative Works (as that term is defined under US copyright law). This means that in addition to making unlimited copies of the Software, you have a copyright license to modify the Software and to use all or p
-art of the Software to create a Derivative Work.
-\par 
-\par }{\b\insrsid12150908\charrsid12150908 Q: What patent rights does the license grant me?
-\par }{\insrsid12150908 A: This license grants you a patent license to use and distribute the Software under any Microsoft patent claims that read on the Software itself. In other wo
-rds, if you create a modified version of the Software, you still retain the patent license to use and distribute the original portions of the Software under the specific Microsoft patent claims that read on the Software, but you do not have a patent licen
-s
-e as to the new functionality you may have added by modifying the Software. This result is typical of many common open source licenses, including the Common Public License (CPL) and the Mozilla Public License (MPL). In addition, this license grants no rig
-h
-ts to any Microsoft patents that read on other components or files not included in the Software. This means that no patent license is granted to use or distribute any other software or technology that may be needed to use the Software or was created from 
-t
-he Software (for example, any compiled output of the Software, the combination of the Software with other hardware or other software, or any additional enabling technologies that may be necessary to make or use the Software or any final product that inclu
-des the Software).}{\insrsid12150908 
-\par }{\insrsid12150908\charrsid1250157 
-\par }}

docs/README.txt

@@ -1,9 +1,33 @@
-!! Umbraco - the simple, flexible and friendly ASP.NET CMS
+Umbraco - the simple, flexible and friendly ASP.NET CMS
+=======================================================
 For the first time on the Microsoft platform a free user and developer friendly cms that makes it quick and easy to create websites - or a breeze to build complex web applications. umbraco got award-winning integration capabilities and supports your ASP.NET User and Custom Controls out of the box. It's a developers dream and your users will love it too. Used by more than 57.000 active websites including Heinz.com, Peugeot.com, NAIAS.com and Microsofts documentinteropinitiative.org website you can be sure that the technology is proven, stable and scales.
-[url:More info at http://umbraco.org|http://umbraco.org]
 
-!! Forums
-We have a forum running on [url:http://our.umbraco.org]. The discussions area on CodePlex will be for discussions on developing the core, and not on Umbraco-implementations or extensions in general. For those topics, please use [url:http://our.umbraco.org].
+More info at http://umbraco.com
 
-!! Submitting Issues
-Another way you can contribute to Umbraco is by providing issue reports, for information on how to submit an issue report refer to our [url:online guide|http://our.umbraco.org/wiki/how-tos/submitting-bug-reports].
+Exploring the repository
+========================
+Most contributors will work on their own fork and should pick the branch in which they need their fix. For more information see:
+http://our.umbraco.org/contribute/guidelines-for-core-contribution
+
+Exploring the source
+====================
+The Umbraco source code is never required for you to start building sites. If you are not using the source code for debugging purposes or to contribute to the source then please download the binaries listed at http://umbraco.codeplex.com
+
+With that said, the Umbraco solution can be opened in Visual Studio 2010 with SP1 installed or Visual Studio 2012.
+
+Contributing
+============
+Umbraco is Open Source which means you can contribute to make it great!
+Read all about it at http://our.umbraco.org/contribute
+
+Forums
+======
+We have a forum running on http://our.umbraco.org for friendly community support.
+
+Documentation
+=============
+Our documentation section provides help on installing and using Umbraco including API reference documentation: http://our.umbraco.org/documentation
+
+Submitting Issues
+=================
+Another way you can contribute to Umbraco is by providing issue reports, for information on how to submit an issue report refer to our online guide at http://our.umbraco.org/contribute/report-an-issue-or-request-a-feature

src/Umbraco.Core/ApplicationContext.cs

@@ -123,6 +123,18 @@ namespace Umbraco.Core
             }
         }
 
+        /// <summary>
+        /// The original/first url that the web application executes
+        /// </summary>
+        /// <remarks>
+        /// we need to set the initial url in our ApplicationContext, this is so our keep alive service works and this must
+        /// exist on a global context because the keep alive service doesn't run in a web context.
+        /// we are NOT going to put a lock on this because locking will slow down the application and we don't really care
+        /// if two threads write to this at the exact same time during first page hit.
+        /// see: http://issues.umbraco.org/issue/U4-2059
+        /// </remarks>
+        internal string OriginalRequestUrl { get; set; }
+
 		private bool Configured
 		{
 			get
@@ -163,7 +175,6 @@ namespace Umbraco.Core
 			}			
 		}
 
-
         private void AssertIsReady()
         {
             if (!this.IsReady)
@@ -245,7 +256,7 @@ namespace Umbraco.Core
                 this.ApplicationCache = null;
                 if (_databaseContext != null) //need to check the internal field here
                 {
-                    if (DatabaseContext.Database != null)
+                    if (DatabaseContext.IsDatabaseConfigured)
                     {
                         DatabaseContext.Database.Dispose();       
                     }                    

src/Umbraco.Core/AssemblyExtensions.cs

@@ -19,7 +19,41 @@ namespace Umbraco.Core
 			return new FileInfo(path);
 		}
 
-		/// <summary>
+        /// <summary>
+        /// Returns true if the assembly is the App_Code assembly
+        /// </summary>
+        /// <param name="assembly"></param>
+        /// <returns></returns>
+        public static bool IsAppCodeAssembly(this Assembly assembly)
+        {
+            if (assembly.FullName.StartsWith("App_Code"))
+            {
+                try
+                {
+                    Assembly.Load("App_Code");
+                    return true;
+                }
+                catch (FileNotFoundException)
+                {
+                    //this will occur if it cannot load the assembly
+                    return false;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Returns true if the assembly is the compiled global asax.
+        /// </summary>
+        /// <param name="assembly"></param>
+        /// <returns></returns>
+	    public static bool IsGlobalAsaxAssembly(this Assembly assembly)
+	    {
+            //only way I can figure out how to test is by the name
+            return assembly.FullName.StartsWith("App_global.asax");
+	    }
+
+	    /// <summary>
 		///  Returns the file used to load the assembly
 		/// </summary>
 		/// <param name="assemblyName"></param>

src/Umbraco.Core/Cache/CacheProviderBase.cs

@@ -1,12 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.Text;
-using System.Web.Caching;
 
 namespace Umbraco.Core.Cache
 {
     /// <summary>
-    /// An abstract class for implementing a cache helper
+    /// An abstract class for implementing a basic cache provider
     /// </summary>
     /// <remarks>
     /// THIS MUST REMAIN INTERNAL UNTIL WE STREAMLINE HOW ALL CACHE IS HANDLED, WE NEED TO SUPPORT HTTP RUNTIME CACHE, IN MEMORY CACHE, ETC...
@@ -22,13 +20,5 @@ namespace Umbraco.Core.Cache
         public abstract IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith);
         public abstract T GetCacheItem<T>(string cacheKey);
         public abstract T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem);
-        public abstract T GetCacheItem<T>(string cacheKey, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract T GetCacheItem<T>(string cacheKey, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, Func<T> getCacheItem);
-        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
     }
-}
+}

src/Umbraco.Core/Cache/HttpRuntimeCacheProvider.cs

@@ -11,7 +11,7 @@ namespace Umbraco.Core.Cache
     /// <summary>
     /// A CacheProvider that wraps the logic of the HttpRuntime.Cache
     /// </summary>
-    internal class HttpRuntimeCacheProvider : CacheProviderBase
+    internal class HttpRuntimeCacheProvider : RuntimeCacheProviderBase
     {
         private readonly System.Web.Caching.Cache _cache;
         private static readonly object Locker = new object();

src/Umbraco.Core/Cache/NullCacheProvider.cs

@@ -5,7 +5,7 @@ using System.Web.Caching;
 
 namespace Umbraco.Core.Cache
 {
-    internal class NullCacheProvider : CacheProviderBase
+    internal class NullCacheProvider : RuntimeCacheProviderBase
     {
         public override void ClearAllCache()
         {

src/Umbraco.Core/Cache/RuntimeCacheProviderBase.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Text;
+using System.Web.Caching;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// An abstract class for implementing a runtime cache provider
+    /// </summary>
+    /// <remarks>
+    /// THIS MUST REMAIN INTERNAL UNTIL WE STREAMLINE HOW ALL CACHE IS HANDLED, WE NEED TO SUPPORT HTTP RUNTIME CACHE, IN MEMORY CACHE, ETC...
+    /// </remarks>
+    internal abstract class RuntimeCacheProviderBase : CacheProviderBase
+    {
+        public abstract T GetCacheItem<T>(string cacheKey, TimeSpan? timeout, Func<T> getCacheItem);
+        public abstract T GetCacheItem<T>(string cacheKey, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem);
+        public abstract T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem);
+        public abstract T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
+        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, Func<T> getCacheItem);
+        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, TimeSpan? timeout, Func<T> getCacheItem);
+        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
+        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
+    }
+}

src/Umbraco.Core/Cache/StaticCacheProvider.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Web.Caching;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// A cache provider that statically caches everything in an in memory dictionary
+    /// </summary>
+    internal class StaticCacheProvider : CacheProviderBase
+    {
+        private readonly ConcurrentDictionary<string, object> _staticCache = new ConcurrentDictionary<string, object>();
+
+        public override void ClearAllCache()
+        {
+            _staticCache.Clear();
+        }
+
+        public override void ClearCacheItem(string key)
+        {
+            object val;
+            _staticCache.TryRemove(key, out val);
+        }
+
+        public override void ClearCacheObjectTypes(string typeName)
+        {
+            foreach (var key in _staticCache.Keys)
+            {
+                if (_staticCache[key] != null
+                    && _staticCache[key].GetType().ToString().InvariantEquals(typeName))
+                {
+                    object val;
+                    _staticCache.TryRemove(key, out val);
+                }
+            }
+        }
+
+        public override void ClearCacheObjectTypes<T>()
+        {
+            foreach (var key in _staticCache.Keys)
+            {
+                if (_staticCache[key] != null
+                    && _staticCache[key].GetType() == typeof(T))
+                {
+                    object val;
+                    _staticCache.TryRemove(key, out val);
+                }
+            }
+        }
+
+        public override void ClearCacheByKeySearch(string keyStartsWith)
+        {
+            foreach (var key in _staticCache.Keys)
+            {
+                if (key.InvariantStartsWith(keyStartsWith))
+                {
+                    ClearCacheItem(key);
+                }
+            }
+        }
+
+        public override void ClearCacheByKeyExpression(string regexString)
+        {
+            foreach (var key in _staticCache.Keys)
+            {
+                if (Regex.IsMatch(key, regexString))
+                {
+                    ClearCacheItem(key);
+                }
+            }
+        }
+
+        public override IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
+        {
+            return (from KeyValuePair<string, object> c in _staticCache
+                    where c.Key.InvariantStartsWith(keyStartsWith)
+                    select c.Value.TryConvertTo<T>()
+                    into attempt
+                    where attempt.Success
+                    select attempt.Result).ToList();
+        }
+
+        public override T GetCacheItem<T>(string cacheKey)
+        {
+            var result = _staticCache[cacheKey];
+            if (result == null)
+            {
+                return default(T);
+            }
+            return result.TryConvertTo<T>().Result;
+        }
+
+        public override T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem)
+        {
+            return (T)_staticCache.GetOrAdd(cacheKey, getCacheItem);
+        }
+        
+    }
+}

src/Umbraco.Core/CacheHelper.cs

@@ -15,14 +15,13 @@ namespace Umbraco.Core
 	/// <summary>
 	/// Class that is exposed by the ApplicationContext for application wide caching purposes
 	/// </summary>
-	/// <remarks>
-	/// This class may be opened publicly at some point but needs a review of what is absoletely necessary.
-	/// </remarks>
-    public class CacheHelper  //: CacheProviderBase
+    public class CacheHelper
 	{
 	    private readonly bool _enableCache;
-	    private readonly HttpRuntimeCacheProvider _httpCache;
-	    private readonly NullCacheProvider _nullCache = new NullCacheProvider();
+        private readonly CacheProviderBase _staticCache;
+        private readonly CacheProviderBase _nullStaticCache = new NullCacheProvider();
+        private readonly RuntimeCacheProviderBase _httpCache;
+        private readonly RuntimeCacheProviderBase _nullHttpCache = new NullCacheProvider();
 
 		public CacheHelper(System.Web.Caching.Cache cache)
             : this(cache, true)
@@ -30,21 +29,185 @@ namespace Umbraco.Core
 		}
 
 	    internal CacheHelper(System.Web.Caching.Cache cache, bool enableCache)
-	    {
-            _httpCache = new HttpRuntimeCacheProvider(cache);
-	        _enableCache = enableCache;
+            : this(new HttpRuntimeCacheProvider(cache), enableCache)
+	    {            
 	    }
-        
+
+        internal CacheHelper(RuntimeCacheProviderBase httpCacheProvider, bool enableCache)
+            : this(httpCacheProvider, new StaticCacheProvider(), enableCache)
+        {
+        }
+
+        internal CacheHelper(RuntimeCacheProviderBase httpCacheProvider, CacheProviderBase staticCacheProvider, bool enableCache)
+        {
+            _httpCache = httpCacheProvider;
+            _staticCache = staticCacheProvider;
+            _enableCache = enableCache;
+        }
+
+        #region Static cache
+
+        /// <summary>
+        /// Clears the item in umbraco's static cache
+        /// </summary>
+        internal void ClearAllStaticCache()
+        {
+            if (!_enableCache)
+            {
+                _nullStaticCache.ClearAllCache();
+            }
+            else
+            {
+                _staticCache.ClearAllCache();
+            }
+        }
+
+        /// <summary>
+        /// Clears the item in umbraco's static cache with the given key 
+        /// </summary>
+        /// <param name="key">Key</param>
+        internal void ClearStaticCacheItem(string key)
+        {
+            if (!_enableCache)
+            {
+                _nullStaticCache.ClearCacheItem(key);
+            }
+            else
+            {
+                _staticCache.ClearCacheItem(key);
+            }
+        }
+
+        /// <summary>
+        /// Clears all objects in the static cache with the System.Type name as the
+        /// input parameter. (using [object].GetType())
+        /// </summary>
+        /// <param name="typeName">The name of the System.Type which should be cleared from cache ex "System.Xml.XmlDocument"</param>
+        internal void ClearStaticCacheObjectTypes(string typeName)
+        {
+            if (!_enableCache)
+            {
+                _nullStaticCache.ClearCacheObjectTypes(typeName);
+            }
+            else
+            {
+                _staticCache.ClearCacheObjectTypes(typeName);
+            }
+        }
+
+        /// <summary>
+        /// Clears all objects in the static cache with the System.Type specified
+        /// </summary>
+        internal void ClearStaticCacheObjectTypes<T>()
+        {
+            if (!_enableCache)
+            {
+                _nullStaticCache.ClearCacheObjectTypes<T>();
+            }
+            else
+            {
+                _staticCache.ClearCacheObjectTypes<T>();
+            }
+        }
+
+        /// <summary>
+        /// Clears all static cache items that starts with the key passed.
+        /// </summary>
+        /// <param name="keyStartsWith">The start of the key</param>
+        internal void ClearStaticCacheByKeySearch(string keyStartsWith)
+        {
+            if (!_enableCache)
+            {
+                _nullStaticCache.ClearCacheByKeySearch(keyStartsWith);
+            }
+            else
+            {
+                _staticCache.ClearCacheByKeySearch(keyStartsWith);
+            }
+        }
+
+        /// <summary>
+        /// Clears all cache items that have a key that matches the regular expression
+        /// </summary>
+        /// <param name="regexString"></param>
+        internal void ClearStaticCacheByKeyExpression(string regexString)
+        {
+            if (!_enableCache)
+            {
+                _nullStaticCache.ClearCacheByKeyExpression(regexString);
+            }
+            else
+            {
+                _staticCache.ClearCacheByKeyExpression(regexString);
+            }
+        }
+
+        internal IEnumerable<T> GetStaticCacheItemsByKeySearch<T>(string keyStartsWith)
+        {
+            if (!_enableCache)
+            {
+                return _nullStaticCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
+            }
+            else
+            {
+                return _staticCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
+            }
+        }
+
+        /// <summary>
+        /// Returns a static cache item by key, does not update the cache if it isn't there.
+        /// </summary>
+        /// <typeparam name="TT"></typeparam>
+        /// <param name="cacheKey"></param>
+        /// <returns></returns>
+        internal TT GetStaticCacheItem<TT>(string cacheKey)
+        {
+            if (!_enableCache)
+            {
+                return _nullStaticCache.GetCacheItem<TT>(cacheKey);
+            }
+            else
+            {
+                return _staticCache.GetCacheItem<TT>(cacheKey);
+            }
+        }
+
+        /// <summary>
+        /// Gets (and adds if necessary) an item from the static cache with all of the default parameters
+        /// </summary>
+        /// <typeparam name="TT"></typeparam>
+        /// <param name="cacheKey"></param>
+        /// <param name="getCacheItem"></param>
+        /// <returns></returns>
+        internal TT GetStaticCacheItem<TT>(string cacheKey, Func<TT> getCacheItem)
+        {
+            if (!_enableCache)
+            {
+                return _nullStaticCache.GetCacheItem<TT>(cacheKey, getCacheItem);
+            }
+            else
+            {
+                return _staticCache.GetCacheItem<TT>(cacheKey, getCacheItem);
+            }
+        }
+
+        #endregion
+
+
+	    #region Runtime/Http Cache
+        /// <summary>
+        /// Clears the item in umbraco's runtime cache
+        /// </summary>
         public void ClearAllCache()
-        {                         
-			if (!_enableCache)
-			{
-			    _nullCache.ClearAllCache();
-			}
-			else
-			{
-			    _httpCache.ClearAllCache();
-			}
+        {
+            if (!_enableCache)
+            {
+                _nullHttpCache.ClearAllCache();
+            }
+            else
+            {
+                _httpCache.ClearAllCache();
+            }
         }
 
         /// <summary>
@@ -55,7 +218,7 @@ namespace Umbraco.Core
         {
             if (!_enableCache)
             {
-                _nullCache.ClearCacheItem(key);
+                _nullHttpCache.ClearCacheItem(key);
             }
             else
             {
@@ -73,7 +236,7 @@ namespace Umbraco.Core
         {
             if (!_enableCache)
             {
-                _nullCache.ClearCacheObjectTypes(typeName);
+                _nullHttpCache.ClearCacheObjectTypes(typeName);
             }
             else
             {
@@ -84,55 +247,55 @@ namespace Umbraco.Core
         /// <summary>
         /// Clears all objects in the System.Web.Cache with the System.Type specified
         /// </summary>
-	    public void ClearCacheObjectTypes<T>()
-	    {
+        public void ClearCacheObjectTypes<T>()
+        {
             if (!_enableCache)
             {
-                _nullCache.ClearCacheObjectTypes<T>();
+                _nullHttpCache.ClearCacheObjectTypes<T>();
             }
             else
             {
                 _httpCache.ClearCacheObjectTypes<T>();
             }
-	    }
+        }
 
-	    /// <summary>
+        /// <summary>
         /// Clears all cache items that starts with the key passed.
         /// </summary>
         /// <param name="keyStartsWith">The start of the key</param>
         public void ClearCacheByKeySearch(string keyStartsWith)
-	    {
+        {
             if (!_enableCache)
             {
-                _nullCache.ClearCacheByKeySearch(keyStartsWith);
+                _nullHttpCache.ClearCacheByKeySearch(keyStartsWith);
             }
             else
             {
                 _httpCache.ClearCacheByKeySearch(keyStartsWith);
             }
-	    }
+        }
 
         /// <summary>
         /// Clears all cache items that have a key that matches the regular expression
         /// </summary>
         /// <param name="regexString"></param>
-	    public void ClearCacheByKeyExpression(string regexString)
-	    {
+        public void ClearCacheByKeyExpression(string regexString)
+        {
             if (!_enableCache)
             {
-                _nullCache.ClearCacheByKeyExpression(regexString);
+                _nullHttpCache.ClearCacheByKeyExpression(regexString);
             }
             else
             {
                 _httpCache.ClearCacheByKeyExpression(regexString);
             }
-	    }
+        }
 
         public IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
         {
             if (!_enableCache)
             {
-                return _nullCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
+                return _nullHttpCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
             }
             else
             {
@@ -140,7 +303,7 @@ namespace Umbraco.Core
             }
         }
 
-	    /// <summary>
+        /// <summary>
         /// Returns a cache item by key, does not update the cache if it isn't there.
         /// </summary>
         /// <typeparam name="TT"></typeparam>
@@ -150,7 +313,7 @@ namespace Umbraco.Core
         {
             if (!_enableCache)
             {
-                return _nullCache.GetCacheItem<TT>(cacheKey);
+                return _nullHttpCache.GetCacheItem<TT>(cacheKey);
             }
             else
             {
@@ -169,7 +332,7 @@ namespace Umbraco.Core
         {
             if (!_enableCache)
             {
-                return _nullCache.GetCacheItem<TT>(cacheKey, getCacheItem);
+                return _nullHttpCache.GetCacheItem<TT>(cacheKey, getCacheItem);
             }
             else
             {
@@ -190,7 +353,7 @@ namespace Umbraco.Core
         {
             if (!_enableCache)
             {
-                return _nullCache.GetCacheItem<TT>(cacheKey, timeout, getCacheItem);
+                return _nullHttpCache.GetCacheItem<TT>(cacheKey, timeout, getCacheItem);
             }
             else
             {
@@ -213,7 +376,7 @@ namespace Umbraco.Core
         {
             if (!_enableCache)
             {
-                return _nullCache.GetCacheItem<TT>(cacheKey, refreshAction, timeout, getCacheItem);
+                return _nullHttpCache.GetCacheItem<TT>(cacheKey, refreshAction, timeout, getCacheItem);
             }
             else
             {
@@ -237,7 +400,7 @@ namespace Umbraco.Core
         {
             if (!_enableCache)
             {
-                return _nullCache.GetCacheItem<TT>(cacheKey, priority, refreshAction, timeout, getCacheItem);
+                return _nullHttpCache.GetCacheItem<TT>(cacheKey, priority, refreshAction, timeout, getCacheItem);
             }
             else
             {
@@ -257,15 +420,15 @@ namespace Umbraco.Core
         /// <param name="getCacheItem"></param>
         /// <returns></returns>
         public TT GetCacheItem<TT>(string cacheKey,
-            CacheItemPriority priority, 
-			CacheItemRemovedCallback refreshAction,
-            CacheDependency cacheDependency, 
-			TimeSpan timeout, 
-			Func<TT> getCacheItem)
+            CacheItemPriority priority,
+            CacheItemRemovedCallback refreshAction,
+            CacheDependency cacheDependency,
+            TimeSpan timeout,
+            Func<TT> getCacheItem)
         {
             if (!_enableCache)
             {
-                return _nullCache.GetCacheItem<TT>(cacheKey, priority, refreshAction, cacheDependency, timeout, getCacheItem);
+                return _nullHttpCache.GetCacheItem<TT>(cacheKey, priority, refreshAction, cacheDependency, timeout, getCacheItem);
             }
             else
             {
@@ -289,7 +452,7 @@ namespace Umbraco.Core
         {
             if (!_enableCache)
             {
-                return _nullCache.GetCacheItem<TT>(cacheKey, priority, null, cacheDependency, null, getCacheItem);
+                return _nullHttpCache.GetCacheItem<TT>(cacheKey, priority, null, cacheDependency, null, getCacheItem);
             }
             else
             {
@@ -310,14 +473,14 @@ namespace Umbraco.Core
         {
             if (!_enableCache)
             {
-                _nullCache.InsertCacheItem<T>(cacheKey, priority, getCacheItem);
+                _nullHttpCache.InsertCacheItem<T>(cacheKey, priority, getCacheItem);
             }
             else
             {
                 _httpCache.InsertCacheItem<T>(cacheKey, priority, getCacheItem);
             }
         }
-		
+
         /// <summary>
         /// Inserts an item into the cache, if it already exists in the cache it will be replaced
         /// </summary>
@@ -333,7 +496,7 @@ namespace Umbraco.Core
         {
             if (!_enableCache)
             {
-                _nullCache.InsertCacheItem<T>(cacheKey, priority, timeout, getCacheItem);
+                _nullHttpCache.InsertCacheItem<T>(cacheKey, priority, timeout, getCacheItem);
             }
             else
             {
@@ -341,30 +504,30 @@ namespace Umbraco.Core
             }
         }
 
-	    /// <summary>
-	    /// Inserts an item into the cache, if it already exists in the cache it will be replaced
-	    /// </summary>
-	    /// <typeparam name="T"></typeparam>
-	    /// <param name="cacheKey"></param>
-	    /// <param name="priority"></param>
-	    /// <param name="cacheDependency"></param>
-	    /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
-	    /// <param name="getCacheItem"></param>
-	    public void InsertCacheItem<T>(string cacheKey,
-	                                   CacheItemPriority priority,
-	                                   CacheDependency cacheDependency,
-	                                   TimeSpan timeout,
-	                                   Func<T> getCacheItem)
-	    {
+        /// <summary>
+        /// Inserts an item into the cache, if it already exists in the cache it will be replaced
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="cacheKey"></param>
+        /// <param name="priority"></param>
+        /// <param name="cacheDependency"></param>
+        /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
+        /// <param name="getCacheItem"></param>
+        public void InsertCacheItem<T>(string cacheKey,
+                                       CacheItemPriority priority,
+                                       CacheDependency cacheDependency,
+                                       TimeSpan timeout,
+                                       Func<T> getCacheItem)
+        {
             if (!_enableCache)
             {
-                _nullCache.InsertCacheItem<T>(cacheKey, priority, cacheDependency, timeout, getCacheItem);
+                _nullHttpCache.InsertCacheItem<T>(cacheKey, priority, cacheDependency, timeout, getCacheItem);
             }
             else
             {
                 _httpCache.InsertCacheItem<T>(cacheKey, priority, cacheDependency, timeout, getCacheItem);
             }
-	    }
+        }
 
         /// <summary>
         /// Inserts an item into the cache, if it already exists in the cache it will be replaced
@@ -376,22 +539,23 @@ namespace Umbraco.Core
         /// <param name="cacheDependency"></param>
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
-	    public void InsertCacheItem<T>(string cacheKey,
-	                                   CacheItemPriority priority,
-	                                   CacheItemRemovedCallback refreshAction,
-	                                   CacheDependency cacheDependency,
-	                                   TimeSpan? timeout,
-	                                   Func<T> getCacheItem)
-	    {
+        public void InsertCacheItem<T>(string cacheKey,
+                                       CacheItemPriority priority,
+                                       CacheItemRemovedCallback refreshAction,
+                                       CacheDependency cacheDependency,
+                                       TimeSpan? timeout,
+                                       Func<T> getCacheItem)
+        {
             if (!_enableCache)
             {
-                _nullCache.InsertCacheItem<T>(cacheKey, priority, refreshAction, cacheDependency, timeout, getCacheItem);
+                _nullHttpCache.InsertCacheItem<T>(cacheKey, priority, refreshAction, cacheDependency, timeout, getCacheItem);
             }
             else
             {
                 _httpCache.InsertCacheItem<T>(cacheKey, priority, refreshAction, cacheDependency, timeout, getCacheItem);
             }
-	    }
+        } 
+        #endregion
 
 	}
 

src/Umbraco.Core/Configuration/CaseInsensitiveEnumConfigConverter.cs

@@ -10,7 +10,7 @@ namespace Umbraco.Core.Configuration
     /// A case-insensitive configuration converter for enumerations.
     /// </summary>
     /// <typeparam name="T">The type of the enumeration.</typeparam>
-    internal class CaseInsensitiveEnumConfigConverter<T> : ConfigurationConverterBase
+    public class CaseInsensitiveEnumConfigConverter<T> : ConfigurationConverterBase
         where T : struct
     {
         public override object ConvertFrom(ITypeDescriptorContext ctx, CultureInfo ci, object data)

src/Umbraco.Core/Configuration/ConfigurationKeyAttribute.cs

@@ -9,7 +9,7 @@ namespace Umbraco.Core.Configuration
 	/// Indicates the configuration key for a section or a group.
 	/// </summary>
 	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
-	internal sealed class ConfigurationKeyAttribute : Attribute
+	public sealed class ConfigurationKeyAttribute : Attribute
 	{
 	    /// <summary>
 	    /// Initializes a new instance of the <see cref="ConfigurationKeyAttribute"/> class with a configuration key.

src/Umbraco.Core/Configuration/UmbracoConfigurationSection.cs

@@ -16,7 +16,7 @@ namespace Umbraco.Core.Configuration
     /// <para>The <c>UmbracoSettings.For{T}</c> method will return a section, either one that
     /// is in the configuration file, or a section that was created with default values.</para>
     /// </remarks>
-    internal abstract class UmbracoConfigurationSection : ConfigurationSection
+    public abstract class UmbracoConfigurationSection : ConfigurationSection
     {
         /// <summary>
         /// Gets a value indicating whether the section actually is in the configuration file.

src/Umbraco.Core/Configuration/UmbracoSettings.cs

@@ -135,7 +135,7 @@ namespace Umbraco.Core.Configuration
 		/// </summary>
 		/// <param name="key">The xpath query to the specific node.</param>
 		/// <returns>If found, it returns the specific configuration xml node.</returns>
-		public static XmlNode GetKeyAsNode(string key)
+		internal static XmlNode GetKeyAsNode(string key)
 		{
 			if (key == null)
 				throw new ArgumentException("Key cannot be null");
@@ -150,7 +150,7 @@ namespace Umbraco.Core.Configuration
 		/// </summary>
 		/// <param name="key">The key.</param>
 		/// <returns></returns>
-		public static string GetKey(string key)
+        internal static string GetKey(string key)
 		{
 			EnsureSettingsDocument();
 
@@ -187,7 +187,7 @@ namespace Umbraco.Core.Configuration
 		/// <value>
 		/// 	<c>true</c> if new directories are allowed otherwise, <c>false</c>.
 		/// </value>
-		public static bool UploadAllowDirectories
+        internal static bool UploadAllowDirectories
 		{
 			get { return bool.Parse(GetKey("/settings/content/UploadAllowDirectories")); }
 		}
@@ -214,7 +214,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets a value indicating whether logging is enabled in umbracoSettings.config (/settings/logging/enableLogging).
 		/// </summary>
 		/// <value><c>true</c> if logging is enabled; otherwise, <c>false</c>.</value>
-		public static bool EnableLogging
+        internal static bool EnableLogging
 		{
 			get
 			{
@@ -229,7 +229,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets a value indicating whether logging happens async.
 		/// </summary>
 		/// <value><c>true</c> if async logging is enabled; otherwise, <c>false</c>.</value>
-		public static bool EnableAsyncLogging
+        internal static bool EnableAsyncLogging
 		{
 			get
 			{
@@ -244,7 +244,7 @@ namespace Umbraco.Core.Configuration
 		/// <summary>
 		/// Gets the assembly of an external logger that can be used to store log items in 3rd party systems
 		/// </summary>
-		public static string ExternalLoggerAssembly
+        internal static string ExternalLoggerAssembly
 		{
 			get
 			{
@@ -256,7 +256,7 @@ namespace Umbraco.Core.Configuration
 		/// <summary>
 		/// Gets the type of an external logger that can be used to store log items in 3rd party systems
 		/// </summary>
-		public static string ExternalLoggerType
+        internal static string ExternalLoggerType
 		{
 			get
 			{
@@ -268,7 +268,7 @@ namespace Umbraco.Core.Configuration
 		/// <summary>
 		/// Long Audit Trail to external log too
 		/// </summary>
-		public static bool ExternalLoggerLogAuditTrail
+        internal static bool ExternalLoggerLogAuditTrail
 		{
 			get
 			{
@@ -287,7 +287,7 @@ namespace Umbraco.Core.Configuration
         /// <summary>
         /// Keep user alive as long as they have their browser open? Default is true
         /// </summary>
-        public static bool KeepUserLoggedIn
+        internal static bool KeepUserLoggedIn
         {
             get
             {
@@ -302,7 +302,7 @@ namespace Umbraco.Core.Configuration
         /// <summary>
         /// Enables the experimental canvas (live) editing on the frontend of the website
         /// </summary>
-        public static bool EnableCanvasEditing
+        internal static bool EnableCanvasEditing
         {
             get
             {
@@ -317,7 +317,7 @@ namespace Umbraco.Core.Configuration
         /// <summary>
 		/// Show disabled users in the tree in the Users section in the backoffice
 		/// </summary>
-		public static bool HideDisabledUsersInBackoffice
+        internal static bool HideDisabledUsersInBackoffice
 		{
 			get
 			{
@@ -333,7 +333,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets a value indicating whether the logs will be auto cleaned
 		/// </summary>
 		/// <value><c>true</c> if logs are to be automatically cleaned; otherwise, <c>false</c></value>
-		public static bool AutoCleanLogs
+        internal static bool AutoCleanLogs
 		{
 			get
 			{
@@ -348,7 +348,7 @@ namespace Umbraco.Core.Configuration
 		/// <summary>
 		/// Gets the value indicating the log cleaning frequency (in miliseconds)
 		/// </summary>
-		public static int CleaningMiliseconds
+        internal static int CleaningMiliseconds
 		{
 			get
 			{
@@ -360,7 +360,7 @@ namespace Umbraco.Core.Configuration
 			}
 		}
 
-		public static int MaxLogAge
+        internal static int MaxLogAge
 		{
 			get
 			{
@@ -376,7 +376,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets the disabled log types.
 		/// </summary>
 		/// <value>The disabled log types.</value>
-		public static XmlNode DisabledLogTypes
+        internal static XmlNode DisabledLogTypes
 		{
 			get { return GetKeyAsNode("/settings/logging/disabledLogTypes"); }
 		}
@@ -385,7 +385,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets the package server url.
 		/// </summary>
 		/// <value>The package server url.</value>
-		public static string PackageServer
+        internal static string PackageServer
 		{
 			get { return "packages.umbraco.org"; }
 		}
@@ -396,15 +396,14 @@ namespace Umbraco.Core.Configuration
 		/// Gets a value indicating whether umbraco will use domain prefixes.
 		/// </summary>
 		/// <value><c>true</c> if umbraco will use domain prefixes; otherwise, <c>false</c>.</value>
-		// TODO rename as EnforceAbsoluteUrls
-		public static bool UseDomainPrefixes
+        internal static bool UseDomainPrefixes
 		{
 			get
 			{
                 // default: false
                 return _useDomainPrefixes ?? GetKeyValue("/settings/requestHandler/useDomainPrefixes", false);
 			}
-			internal set
+			/*internal*/ set
 			{
                 // for unit tests only
                 _useDomainPrefixes = value;
@@ -417,7 +416,7 @@ namespace Umbraco.Core.Configuration
 		/// This will add a trailing slash (/) to urls when in directory url mode
 		/// NOTICE: This will always return false if Directory Urls in not active
 		/// </summary>
-		public static bool AddTrailingSlash
+        internal static bool AddTrailingSlash
 		{
 			get
 			{
@@ -425,7 +424,7 @@ namespace Umbraco.Core.Configuration
                 return GlobalSettings.UseDirectoryUrls
                     && (_addTrailingSlash ?? GetKeyValue("/settings/requestHandler/addTrailingSlash", false));
 			}
-			internal set
+			/*internal*/ set
 			{
                 // for unit tests only
                 _addTrailingSlash = value;
@@ -436,7 +435,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets a value indicating whether umbraco will use ASP.NET MasterPages for rendering instead of its propriatary templating system.
 		/// </summary>
 		/// <value><c>true</c> if umbraco will use ASP.NET MasterPages; otherwise, <c>false</c>.</value>
-		public static bool UseAspNetMasterPages
+        internal static bool UseAspNetMasterPages
 		{
 			get
 			{
@@ -458,7 +457,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets a value indicating whether umbraco will attempt to load any skins to override default template files
 		/// </summary>
 		/// <value><c>true</c> if umbraco will override templates with skins if present and configured <c>false</c>.</value>
-		public static bool EnableTemplateFolders
+        internal static bool EnableTemplateFolders
 		{
 			get
 			{
@@ -482,7 +481,7 @@ namespace Umbraco.Core.Configuration
 		/// <summary>
 		/// razor DynamicNode typecasting detects XML and returns DynamicXml - Root elements that won't convert to DynamicXml
 		/// </summary>
-		public static IEnumerable<string> NotDynamicXmlDocumentElements
+        internal static IEnumerable<string> NotDynamicXmlDocumentElements
 		{
 			get
 			{
@@ -571,7 +570,7 @@ namespace Umbraco.Core.Configuration
 		/// <value>
 		/// 	<c>true</c> if umbraco will clone XML cache on publish; otherwise, <c>false</c>.
 		/// </value>
-		public static bool CloneXmlCacheOnPublish
+        internal static bool CloneXmlCacheOnPublish
 		{
 			get
 			{
@@ -593,7 +592,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets a value indicating whether rich text editor content should be parsed by tidy.
 		/// </summary>
 		/// <value><c>true</c> if content is parsed; otherwise, <c>false</c>.</value>
-		public static bool TidyEditorContent
+        internal static bool TidyEditorContent
 		{
 			get { return bool.Parse(GetKey("/settings/content/TidyEditorContent")); }
 		}
@@ -602,7 +601,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets the encoding type for the tidyied content.
 		/// </summary>
 		/// <value>The encoding type as string.</value>
-		public static string TidyCharEncoding
+        internal static string TidyCharEncoding
 		{
 			get
 			{
@@ -619,12 +618,12 @@ namespace Umbraco.Core.Configuration
 		/// Gets the property context help option, this can either be 'text', 'icon' or 'none'
 		/// </summary>
 		/// <value>The property context help option.</value>
-		public static string PropertyContextHelpOption
+        internal static string PropertyContextHelpOption
 		{
 			get { return GetKey("/settings/content/PropertyContextHelpOption").ToLower(); }
 		}
 
-		public static string DefaultBackofficeProvider
+        internal static string DefaultBackofficeProvider
 		{
 			get
 			{
@@ -641,14 +640,14 @@ namespace Umbraco.Core.Configuration
 		/// <summary>
 		/// Whether to force safe aliases (no spaces, no special characters) at businesslogic level on contenttypes and propertytypes
 		/// </summary>
-		public static bool ForceSafeAliases
+        internal static bool ForceSafeAliases
 		{
 			get
 			{
                 // default: true
                 return _forceSafeAliases ?? GetKeyValue("/settings/content/ForceSafeAliases", true);
 			}
-			internal set
+			/*internal*/ set
 			{
 				// used for unit  testing
 				_forceSafeAliases = value;
@@ -673,11 +672,23 @@ namespace Umbraco.Core.Configuration
             get { return GetKeyValue("/settings/web.routing/@internalRedirectPreservesTemplate", false); }
         }
 
+        /// <summary>
+        /// File types that will not be allowed to be uploaded via the content/media upload control
+        /// </summary>
+	    public static IEnumerable<string> DisallowedUploadFiles
+	    {
+	        get
+	        {
+                var val = GetKey("/settings/content/disallowedUploadFiles");
+	            return val.Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries);
+	        }
+	    }
+
 		/// <summary>
 		/// Gets the allowed image file types.
 		/// </summary>
 		/// <value>The allowed image file types.</value>
-		public static string ImageFileTypes
+        internal static string ImageFileTypes
 		{
 			get { return GetKey("/settings/content/imaging/imageFileTypes").ToLowerInvariant(); }
 		}
@@ -686,7 +697,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets the allowed script file types.
 		/// </summary>
 		/// <value>The allowed script file types.</value>
-		public static string ScriptFileTypes
+        internal static string ScriptFileTypes
 		{
 			get { return GetKey("/settings/content/scripteditor/scriptFileTypes"); }
 		}
@@ -697,14 +708,14 @@ namespace Umbraco.Core.Configuration
 		/// Gets the duration in seconds to cache queries to umbraco library member and media methods
 		/// Default is 1800 seconds (30 minutes)
 		/// </summary>
-		public static int UmbracoLibraryCacheDuration
+        internal static int UmbracoLibraryCacheDuration
 		{
 			get
 			{
                 // default: 1800
                 return _umbracoLibraryCacheDuration ?? GetKeyValue("/settings/content/UmbracoLibraryCacheDuration", 1800);
 			}
-			internal set
+			/*internal*/ set
             {
                 // for unit tests only
                 _umbracoLibraryCacheDuration = value;
@@ -715,7 +726,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets the path to the scripts folder used by the script editor.
 		/// </summary>
 		/// <value>The script folder path.</value>
-		public static string ScriptFolderPath
+        internal static string ScriptFolderPath
 		{
 			get { return GetKey("/settings/content/scripteditor/scriptFolderPath"); }
 		}
@@ -723,7 +734,7 @@ namespace Umbraco.Core.Configuration
 		/// <summary>
 		/// Enabled or disable the script/code editor
 		/// </summary>
-		public static bool ScriptDisableEditor
+        internal static bool ScriptDisableEditor
 		{
 			get
 			{
@@ -741,7 +752,7 @@ namespace Umbraco.Core.Configuration
 		/// ex: existingnodename.aspx would become existingnodename(1).aspx if a node with the same name is found 
 		/// </summary>
 		/// <value><c>true</c> if umbraco ensures unique node naming; otherwise, <c>false</c>.</value>
-		public static bool EnsureUniqueNaming
+        internal static bool EnsureUniqueNaming
 		{
 			get
 			{
@@ -760,7 +771,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets the notification email sender.
 		/// </summary>
 		/// <value>The notification email sender.</value>
-		public static string NotificationEmailSender
+        internal static string NotificationEmailSender
 		{
 			get { return GetKey("/settings/content/notifications/email"); }
 		}
@@ -771,7 +782,7 @@ namespace Umbraco.Core.Configuration
 		/// <value>
 		/// 	<c>true</c> if html notification-emails are disabled; otherwise, <c>false</c>.
 		/// </value>
-		public static bool NotificationDisableHtmlEmail
+        internal static bool NotificationDisableHtmlEmail
 		{
 			get
 			{
@@ -784,12 +795,12 @@ namespace Umbraco.Core.Configuration
 		/// Gets the allowed attributes on images.
 		/// </summary>
 		/// <value>The allowed attributes on images.</value>
-		public static string ImageAllowedAttributes
+        internal static string ImageAllowedAttributes
 		{
 			get { return GetKey("/settings/content/imaging/allowedAttributes"); }
 		}
 
-		public static XmlNode ImageAutoFillImageProperties
+        internal static XmlNode ImageAutoFillImageProperties
 		{
 			get { return GetKeyAsNode("/settings/content/imaging/autoFillImageProperties"); }
 		}
@@ -798,7 +809,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets the scheduled tasks as XML
 		/// </summary>
 		/// <value>The scheduled tasks.</value>
-		public static XmlNode ScheduledTasks
+        internal static XmlNode ScheduledTasks
 		{
 			get { return GetKeyAsNode("/settings/scheduledTasks"); }
 		}
@@ -807,7 +818,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets a list of characters that will be replaced when generating urls
 		/// </summary>
 		/// <value>The URL replacement characters.</value>
-		public static XmlNode UrlReplaceCharacters
+        internal static XmlNode UrlReplaceCharacters
 		{
 			get { return GetKeyAsNode("/settings/requestHandler/urlReplacing"); }
 		}
@@ -815,7 +826,7 @@ namespace Umbraco.Core.Configuration
 		/// <summary>
 		/// Whether to replace double dashes from url (ie my--story----from--dash.aspx caused by multiple url replacement chars
 		/// </summary>
-		public static bool RemoveDoubleDashesFromUrlReplacing
+        internal static bool RemoveDoubleDashesFromUrlReplacing
 		{
 			get
 			{
@@ -836,7 +847,7 @@ namespace Umbraco.Core.Configuration
 		/// Used for load-balancing high-traffic sites.
 		/// </summary>
 		/// <value><c>true</c> if umbraco uses distributed calls; otherwise, <c>false</c>.</value>
-		public static bool UseDistributedCalls
+        internal static bool UseDistributedCalls
 		{
 			get
 			{
@@ -856,7 +867,7 @@ namespace Umbraco.Core.Configuration
 		/// Gets the ID of the user with access rights to perform the distributed calls.
 		/// </summary>
 		/// <value>The distributed call user.</value>
-		public static int DistributedCallUser
+        internal static int DistributedCallUser
 		{
 			get
 			{
@@ -874,7 +885,7 @@ namespace Umbraco.Core.Configuration
 		/// <summary>
 		/// Gets the html injected into a (x)html page if Umbraco is running in preview mode
 		/// </summary>
-		public static string PreviewBadge
+        internal static string PreviewBadge
 		{
 			get
 			{
@@ -895,7 +906,7 @@ namespace Umbraco.Core.Configuration
 		/// and update their content cache accordingly, ensuring a consistent cache on all servers
 		/// </summary>
 		/// <value>The distribution servers.</value>
-		public static XmlNode DistributionServers
+        internal static XmlNode DistributionServers
 		{
 			get
 			{
@@ -915,7 +926,7 @@ namespace Umbraco.Core.Configuration
 		/// A help page configuration specify language, user type, application, application url and 
 		/// the target help page url.
 		/// </summary>
-		public static XmlNode HelpPages
+        internal static XmlNode HelpPages
 		{
 			get
 			{
@@ -937,7 +948,7 @@ namespace Umbraco.Core.Configuration
 		/// All packages installed from a repository gets the repository alias included in the install information
 		/// </summary>
 		/// <value>The repository servers.</value>
-		public static XmlNode Repositories
+        internal static XmlNode Repositories
 		{
 			get
 			{
@@ -960,7 +971,7 @@ namespace Umbraco.Core.Configuration
 		/// <value>
 		/// 	<c>true</c> if umbraco will use the viewstate mover module; otherwise, <c>false</c>.
 		/// </value>
-		public static bool UseViewstateMoverModule
+        internal static bool UseViewstateMoverModule
 		{
 			get
 			{
@@ -982,7 +993,7 @@ namespace Umbraco.Core.Configuration
 		/// Tells us whether the Xml Content cache is disabled or not
 		/// Default is enabled
 		/// </summary>
-		public static bool IsXmlContentCacheDisabled
+        internal static bool IsXmlContentCacheDisabled
 		{
 			get
 			{
@@ -1007,7 +1018,7 @@ namespace Umbraco.Core.Configuration
 		/// Makes it possible to updates environments by syncing the umbraco.config file across instances
 		/// Relates to http://umbraco.codeplex.com/workitem/30722
 		/// </summary>
-		public static bool XmlContentCheckForDiskChanges
+        internal static bool XmlContentCheckForDiskChanges
 		{
 			get
 			{
@@ -1032,7 +1043,7 @@ namespace Umbraco.Core.Configuration
 		/// If disabled, only documents will generate data.
 		/// This feature is useful if anyone would like to see how data looked at a given time
 		/// </summary>
-		public static bool EnableGlobalPreviewStorage
+        internal static bool EnableGlobalPreviewStorage
 		{
 			get
 			{
@@ -1060,14 +1071,14 @@ namespace Umbraco.Core.Configuration
 		/// <value>
 		/// 	<c>true</c> if yes, use the old node/data model; otherwise, <c>false</c>.
 		/// </value>
-		public static bool UseLegacyXmlSchema
+        internal static bool UseLegacyXmlSchema
 		{
 			get
 			{
                 // default: true
                 return _useLegacySchema ?? GetKeyValue("/settings/content/UseLegacyXmlSchema", false);
 			}
-			internal set
+			/*internal*/ set
 			{
 				// used for unit testing
 				_useLegacySchema = value;
@@ -1075,7 +1086,7 @@ namespace Umbraco.Core.Configuration
 		}
 
 		[Obsolete("This setting is not used anymore, the only file extensions that are supported are .cs and .vb files")]
-		public static IEnumerable<string> AppCodeFileExtensionsList
+        internal static IEnumerable<string> AppCodeFileExtensionsList
 		{
 			get
 			{
@@ -1086,7 +1097,7 @@ namespace Umbraco.Core.Configuration
 		}
 
 		[Obsolete("This setting is not used anymore, the only file extensions that are supported are .cs and .vb files")]
-		public static XmlNode AppCodeFileExtensions
+        internal static XmlNode AppCodeFileExtensions
 		{
 			get
 			{
@@ -1108,7 +1119,7 @@ namespace Umbraco.Core.Configuration
 		/// Tells us whether the Xml to always update disk cache, when changes are made to content
 		/// Default is enabled
 		/// </summary>
-		public static bool ContinouslyUpdateXmlDiskCache
+        internal static bool ContinouslyUpdateXmlDiskCache
 		{
 			get
 			{
@@ -1134,7 +1145,7 @@ namespace Umbraco.Core.Configuration
 		/// have a splash page
 		/// Default is disabled
 		/// </summary>
-		public static bool EnableSplashWhileLoading
+        internal static bool EnableSplashWhileLoading
 		{
 			get
 			{
@@ -1155,7 +1166,7 @@ namespace Umbraco.Core.Configuration
 		}
 
 		private static bool? _resolveUrlsFromTextString;
-		public static bool ResolveUrlsFromTextString
+        internal static bool ResolveUrlsFromTextString
 		{
 			get
 			{
@@ -1192,7 +1203,7 @@ namespace Umbraco.Core.Configuration
 		/// is used instead of the masterpages editor
 		/// </summary>
 		/// <value><c>true</c> if umbraco defaults to using MVC views for templating, otherwise <c>false</c>.</value>
-		public static RenderingEngine DefaultRenderingEngine
+        internal static RenderingEngine DefaultRenderingEngine
 		{
 			get
 			{
@@ -1233,7 +1244,7 @@ namespace Umbraco.Core.Configuration
 		/// - Throw  - Throw an exception and invoke the global error handler (if one is defined, if not you'll get a YSOD)
 		/// </summary>
 		/// <value>MacroErrorBehaviour enum defining how to handle macro errors.</value>
-		public static MacroErrorBehaviour MacroErrorBehaviour
+        internal static MacroErrorBehaviour MacroErrorBehaviour
 		{
 			get
 			{
@@ -1268,7 +1279,7 @@ namespace Umbraco.Core.Configuration
         /// - HideFileDuplicates   - Show files in the sprite and hide duplicates on disk
         /// </summary>
         /// <value>MacroErrorBehaviour enum defining how to show icons in the document type editor.</value>
-        public static IconPickerBehaviour IconPickerBehaviour
+        internal static IconPickerBehaviour IconPickerBehaviour
 		{
 			get
 			{
@@ -1504,7 +1515,7 @@ namespace Umbraco.Core.Configuration
         /// </summary>
         /// <typeparam name="T">The type of the UmbracoConfigurationSectiont.</typeparam>
         /// <returns>The UmbracoConfigurationSection of the specified type.</returns>
-        internal static T For<T>()
+        public static T For<T>()
             where T : UmbracoConfigurationSection, new()
         {
             var sectionType = typeof (T);

src/Umbraco.Core/Configuration/UmbracoVersion.cs

@@ -23,7 +23,7 @@ namespace Umbraco.Core.Configuration
         /// Gets the version comment (like beta or RC).
         /// </summary>
         /// <value>The version comment.</value>
-        public static string CurrentComment { get { return "beta"; } }
+        public static string CurrentComment { get { return ""; } }
 
         // Get the version of the umbraco.dll by looking at a class in that dll
         // Had to do it like this due to medium trust issues, see: http://haacked.com/archive/2010/11/04/assembly-location-and-medium-trust.aspx

src/Umbraco.Core/CoreBootManager.cs

@@ -10,6 +10,7 @@ using Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix;
 using Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixZeroOne;
 using Umbraco.Core.Persistence.SqlSyntax;
 using Umbraco.Core.Persistence.UnitOfWork;
+using Umbraco.Core.Profiling;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Publishing;
 using Umbraco.Core.Macros;
@@ -52,8 +53,9 @@ namespace Umbraco.Core
 			if (_isInitialized)
 				throw new InvalidOperationException("The boot manager has already been initialized");
 
-			LogHelper.Info<CoreBootManager>("Umbraco application starting");
-			_timer = DisposableTimer.Start(x => LogHelper.Info<CoreBootManager>("Umbraco application startup complete" + " (took " + x + "ms)"));
+	        InitializeProfilerResolver();
+
+            _timer = DisposableTimer.DebugDuration<CoreBootManager>("Umbraco application starting", "Umbraco application startup complete");
 
 			//create database and service contexts for the app context
 			var dbFactory = new DefaultDatabaseFactory(GlobalSettings.UmbracoConnectionName);
@@ -93,6 +95,20 @@ namespace Umbraco.Core
             ApplicationContext = ApplicationContext.Current = new ApplicationContext(dbContext, serviceContext);
         }
 
+        /// <summary>
+        /// Special method to initialize the ProfilerResolver
+        /// </summary>
+        protected virtual void InitializeProfilerResolver()
+        {
+            //By default we'll initialize the Log profiler (in the web project, we'll override with the web profiler)
+            ProfilerResolver.Current = new ProfilerResolver(new LogProfiler())
+                {
+                    //This is another special resolver that needs to be resolvable before resolution is frozen
+                    //since it is used for profiling the application startup
+                    CanResolveBeforeFrozen = true
+                };
+        }
+
         /// <summary>
         /// Special method to initialize the ApplicationEventsResolver and any modifications required for it such 
         /// as adding custom types to the resolver.
@@ -113,6 +129,17 @@ namespace Umbraco.Core
             ApplicationEventsResolver.Current.AddType<PublishedContentHelper>();
         }
 
+        /// <summary>
+        /// Special method to extend the use of Umbraco by enabling the consumer to overwrite
+        /// the absolute path to the root of an Umbraco site/solution, which is used for stuff
+        /// like Umbraco.Core.IO.IOHelper.MapPath etc.
+        /// </summary>
+        /// <param name="rootPath">Absolute</param>
+        protected virtual void InitializeApplicationRootPath(string rootPath)
+        {
+            Umbraco.Core.IO.IOHelper.SetRootDirectory(rootPath);
+        }
+
 		/// <summary>
 		/// Fires after initialization and calls the callback to allow for customizations to occur & 
         /// Ensure that the OnApplicationStarting methods of the IApplicationEvents are called
@@ -158,7 +185,7 @@ namespace Umbraco.Core
                 .ForEach(x => x.OnApplicationStarted(UmbracoApplication, ApplicationContext));
 
             //Now, startup all of our legacy startup handler
-            ApplicationEventsResolver.Current.InstantiateLegacyStartupHanlders();
+            ApplicationEventsResolver.Current.InstantiateLegacyStartupHandlers();
 
             if (afterComplete != null)
             {
@@ -185,7 +212,8 @@ namespace Umbraco.Core
 		/// Create the resolvers
 		/// </summary>
 		protected virtual void InitializeResolvers()
-		{
+		{           
+
             //by default we'll use the standard configuration based sync
             ServerRegistrarResolver.Current = new ServerRegistrarResolver(
                 new ConfigServerRegistrar()); 
@@ -223,9 +251,6 @@ namespace Umbraco.Core
 			ActionsResolver.Current = new ActionsResolver(
 				() => PluginManager.Current.ResolveActions());
 
-            MacroPropertyTypeResolver.Current = new MacroPropertyTypeResolver(
-                PluginManager.Current.ResolveMacroPropertyTypes());
-
             //the database migration objects
             MigrationResolver.Current = new MigrationResolver(
                 () => PluginManager.Current.ResolveMigrationTypes());

src/Umbraco.Core/DictionaryExtensions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Linq;
@@ -10,10 +11,60 @@ using System.Web;
 namespace Umbraco.Core
 {
 	///<summary>
-	/// Extension methods for dictionary
+	/// Extension methods for dictionary & concurrentdictionary
 	///</summary>
 	internal static class DictionaryExtensions
 	{
+        /// <summary>
+        /// Updates an item with the specified key with the specified value
+        /// </summary>
+        /// <typeparam name="TKey"></typeparam>
+        /// <typeparam name="TValue"></typeparam>
+        /// <param name="dict"></param>
+        /// <param name="key"></param>
+        /// <param name="updateFactory"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// Taken from: http://stackoverflow.com/questions/12240219/is-there-a-way-to-use-concurrentdictionary-tryupdate-with-a-lambda-expression
+        /// 
+        /// If there is an item in the dictionary with the key, it will keep trying to update it until it can
+        /// </remarks>
+        public static bool TryUpdate<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> dict, TKey key, Func<TValue, TValue> updateFactory)
+        {
+            TValue curValue;
+            while (dict.TryGetValue(key, out curValue))
+            {
+                if (dict.TryUpdate(key, updateFactory(curValue), curValue))
+                    return true;
+                //if we're looping either the key was removed by another thread, or another thread
+                //changed the value, so we start again.
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Updates an item with the specified key with the specified value
+        /// </summary>
+        /// <typeparam name="TKey"></typeparam>
+        /// <typeparam name="TValue"></typeparam>
+        /// <param name="dict"></param>
+        /// <param name="key"></param>
+        /// <param name="updateFactory"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// Taken from: http://stackoverflow.com/questions/12240219/is-there-a-way-to-use-concurrentdictionary-tryupdate-with-a-lambda-expression
+        /// 
+        /// WARNING: If the value changes after we've retreived it, then the item will not be updated
+        /// </remarks>
+        public static bool TryUpdateOptimisitic<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> dict, TKey key, Func<TValue, TValue> updateFactory)
+        {
+            TValue curValue;
+            if (!dict.TryGetValue(key, out curValue))
+                return false;
+            dict.TryUpdate(key, updateFactory(curValue), curValue);
+            return true;//note we return true whether we succeed or not, see explanation below.
+        }
+
 		/// <summary>
 		/// Converts a dictionary to another type by only using direct casting
 		/// </summary>

src/Umbraco.Core/DisposableTimer.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Diagnostics;
+using System.Web;
 using Umbraco.Core.Logging;
+using Umbraco.Core.Profiling;
 
 namespace Umbraco.Core
 {
@@ -9,11 +11,17 @@ namespace Umbraco.Core
 	/// </summary>
 	/// <example>
 	/// <code>
+	/// 
+	/// using (DisposableTimer.TraceDuration{MyType}("starting", "finished"))
+	/// {
+    ///     Thread.Sleep(567);
+	/// }
+	/// 
 	/// Console.WriteLine("Testing Stopwatchdisposable, should be 567:");
-	//  using (var timer = new DisposableTimer(result => Console.WriteLine("Took {0}ms", result)))
-	//  {
-	//      Thread.Sleep(567);
-	//  }
+	/// using (var timer = new DisposableTimer(result => Console.WriteLine("Took {0}ms", result)))
+	/// {
+	///     Thread.Sleep(567);
+	/// }
 	/// </code>
 	/// </example>
 	public class DisposableTimer : DisposableObject
@@ -24,7 +32,7 @@ namespace Umbraco.Core
 		protected DisposableTimer(Action<long> callback)
 		{
 			_callback = callback;
-		}
+		}        
 
 		public Stopwatch Stopwatch
 		{
@@ -36,96 +44,149 @@ namespace Umbraco.Core
 		/// </summary>
 		/// <param name="callback">The callback.</param>
 		/// <returns></returns>
+		[Obsolete("Use either TraceDuration or DebugDuration instead of using Start")]
 		public static DisposableTimer Start(Action<long> callback)
 		{
 			return new DisposableTimer(callback);
 		}
 
-		public static DisposableTimer TraceDuration<T>(Func<string> startMessage, Func<string> completeMessage)
-		{
-			return TraceDuration(typeof(T), startMessage, completeMessage);
-		}
+        #region TraceDuration
+        public static DisposableTimer TraceDuration<T>(Func<string> startMessage, Func<string> completeMessage)
+        {
+            return TraceDuration(typeof(T), startMessage, completeMessage);
+        }
 
-		public static DisposableTimer TraceDuration(Type loggerType, Func<string> startMessage, Func<string> completeMessage)
-		{
-			LogHelper.Debug(loggerType, startMessage);
-			return new DisposableTimer(x => LogHelper.Info(loggerType, () => completeMessage() + " (took " + x + "ms)"));
-		}
+        public static DisposableTimer TraceDuration(Type loggerType, Func<string> startMessage, Func<string> completeMessage)
+        {
+            var startMsg = startMessage();
+            LogHelper.Info(loggerType, startMsg);
+            if (HttpContext.Current != null)
+                HttpContext.Current.Trace.Write("Start: " + startMsg);
+            var profiler = ActivateProfiler(loggerType, startMsg);
+            return new DisposableTimer(x =>
+                {
+                    profiler.DisposeIfDisposable();
+                    LogHelper.Info(loggerType, () => completeMessage() + " (took " + x + "ms)");
+                    if (HttpContext.Current != null)
+                        HttpContext.Current.Trace.Write("End: " + startMsg);
+                });
+        }
 
-		/// <summary>
-		/// Adds a start and end log entry as Info and tracks how long it takes until disposed.
-		/// </summary>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="startMessage"></param>
-		/// <param name="completeMessage"></param>
-		/// <returns></returns>
-		public static DisposableTimer TraceDuration<T>(string startMessage, string completeMessage)
-		{
-			return TraceDuration(typeof(T), startMessage, completeMessage);
-		}
+        /// <summary>
+        /// Adds a start and end log entry as Info and tracks how long it takes until disposed.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="startMessage"></param>
+        /// <param name="completeMessage"></param>
+        /// <returns></returns>
+        public static DisposableTimer TraceDuration<T>(string startMessage, string completeMessage)
+        {
+            return TraceDuration(typeof(T), startMessage, completeMessage);
+        }
 
-		/// <summary>
-		/// Adds a start and end log entry as Info and tracks how long it takes until disposed.
-		/// </summary>
-		/// <param name="loggerType"></param>
-		/// <param name="startMessage"></param>
-		/// <param name="completeMessage"></param>
-		/// <returns></returns>
-		public static DisposableTimer TraceDuration(Type loggerType, string startMessage, string completeMessage)
-		{
-			LogHelper.Info(loggerType, () => startMessage);
-			return new DisposableTimer(x => LogHelper.Info(loggerType, () => completeMessage + " (took " + x + "ms)"));
-		}
+        public static DisposableTimer TraceDuration<T>(string startMessage)
+        {
+            return TraceDuration(typeof(T), startMessage, "Complete");
+        }
 
-		/// <summary>
-		/// Adds a start and end log entry as Debug and tracks how long it takes until disposed.
-		/// </summary>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="startMessage"></param>
-		/// <param name="completeMessage"></param>
-		/// <returns></returns>
-		public static DisposableTimer DebugDuration<T>(string startMessage, string completeMessage)
-		{
-			return DebugDuration(typeof(T), startMessage, completeMessage);
-		}
+        /// <summary>
+        /// Adds a start and end log entry as Info and tracks how long it takes until disposed.
+        /// </summary>
+        /// <param name="loggerType"></param>
+        /// <param name="startMessage"></param>
+        /// <param name="completeMessage"></param>
+        /// <returns></returns>
+        public static DisposableTimer TraceDuration(Type loggerType, string startMessage, string completeMessage)
+        {
+            LogHelper.Info(loggerType, startMessage);
+            if (HttpContext.Current != null)
+                HttpContext.Current.Trace.Write("Start: " + startMessage);
+            var profiler = ActivateProfiler(loggerType, startMessage);
+            return new DisposableTimer(x =>
+                {
+                    profiler.DisposeIfDisposable();
+                    LogHelper.Info(loggerType, () => completeMessage + " (took " + x + "ms)");
+                    if (HttpContext.Current != null)
+                        HttpContext.Current.Trace.Write("End: " + startMessage);
+                });
+        } 
+        #endregion
 
-		/// <summary>
-		/// Adds a start and end log entry as Debug and tracks how long it takes until disposed.
-		/// </summary>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="startMessage"></param>
-		/// <param name="completeMessage"></param>
-		/// <returns></returns>
-		public static DisposableTimer DebugDuration<T>(Func<string> startMessage, Func<string> completeMessage)
-		{
-			return DebugDuration(typeof(T), startMessage, completeMessage);
-		}
+        #region DebugDuration
+        /// <summary>
+        /// Adds a start and end log entry as Debug and tracks how long it takes until disposed.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="startMessage"></param>
+        /// <param name="completeMessage"></param>
+        /// <returns></returns>
+        public static DisposableTimer DebugDuration<T>(string startMessage, string completeMessage)
+        {
+            return DebugDuration(typeof(T), startMessage, completeMessage);
+        }
 
-		/// <summary>
-		/// Adds a start and end log entry as Debug and tracks how long it takes until disposed.
-		/// </summary>
-		/// <param name="loggerType"></param>
-		/// <param name="startMessage"></param>
-		/// <param name="completeMessage"></param>
-		/// <returns></returns>
-		public static DisposableTimer DebugDuration(Type loggerType, string startMessage, string completeMessage)
-		{
-			LogHelper.Debug(loggerType, () => startMessage);
-			return new DisposableTimer(x => LogHelper.Debug(loggerType, () => completeMessage + " (took " + x + "ms)"));
-		}
+        public static DisposableTimer DebugDuration<T>(string startMessage)
+        {
+            return DebugDuration(typeof(T), startMessage, "Complete");
+        }
 
-		/// <summary>
-		/// Adds a start and end log entry as Debug and tracks how long it takes until disposed.
-		/// </summary>
-		/// <param name="loggerType"></param>
-		/// <param name="startMessage"></param>
-		/// <param name="completeMessage"></param>
-		/// <returns></returns>
-		public static DisposableTimer DebugDuration(Type loggerType, Func<string> startMessage, Func<string> completeMessage)
-		{
-			LogHelper.Debug(loggerType, startMessage);
-			return new DisposableTimer(x => LogHelper.Debug(loggerType, () => completeMessage() + " (took " + x + "ms)"));
-		}
+        /// <summary>
+        /// Adds a start and end log entry as Debug and tracks how long it takes until disposed.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="startMessage"></param>
+        /// <param name="completeMessage"></param>
+        /// <returns></returns>
+        public static DisposableTimer DebugDuration<T>(Func<string> startMessage, Func<string> completeMessage)
+        {
+            return DebugDuration(typeof(T), startMessage, completeMessage);
+        }
+
+        /// <summary>
+        /// Adds a start and end log entry as Debug and tracks how long it takes until disposed.
+        /// </summary>
+        /// <param name="loggerType"></param>
+        /// <param name="startMessage"></param>
+        /// <param name="completeMessage"></param>
+        /// <returns></returns>
+        public static DisposableTimer DebugDuration(Type loggerType, string startMessage, string completeMessage)
+        {
+            LogHelper.Debug(loggerType, startMessage);
+            if (HttpContext.Current != null)
+                HttpContext.Current.Trace.Write("Start: " + startMessage);
+            var profiler = ActivateProfiler(loggerType, startMessage);
+            return new DisposableTimer(x =>
+                {
+                    profiler.DisposeIfDisposable();
+                    LogHelper.Debug(loggerType, () => completeMessage + " (took " + x + "ms)");
+                    if (HttpContext.Current != null)
+                        HttpContext.Current.Trace.Write("End: " + startMessage);
+                });
+        }
+
+        /// <summary>
+        /// Adds a start and end log entry as Debug and tracks how long it takes until disposed.
+        /// </summary>
+        /// <param name="loggerType"></param>
+        /// <param name="startMessage"></param>
+        /// <param name="completeMessage"></param>
+        /// <returns></returns>
+        public static DisposableTimer DebugDuration(Type loggerType, Func<string> startMessage, Func<string> completeMessage)
+        {
+            var msg = startMessage();
+            LogHelper.Debug(loggerType, msg);
+            if (HttpContext.Current != null)
+                HttpContext.Current.Trace.Write("Start: " + startMessage);
+            var profiler = ActivateProfiler(loggerType, msg);
+            return new DisposableTimer(x =>
+                {
+                    profiler.DisposeIfDisposable();
+                    LogHelper.Debug(loggerType, () => completeMessage() + " (took " + x + "ms)");
+                    if (HttpContext.Current != null)
+                        HttpContext.Current.Trace.Write("End: " + startMessage);
+                });
+        } 
+        #endregion
 
 		/// <summary>
 		/// Handles the disposal of resources. Derived from abstract class <see cref="DisposableObject"/> which handles common required locking logic.
@@ -134,5 +195,19 @@ namespace Umbraco.Core
 		{
 			_callback.Invoke(Stopwatch.ElapsedMilliseconds);
 		}
+
+        private static IDisposable ActivateProfiler(Type loggerType, string profileName)
+        {
+            try
+            {
+                return ProfilerResolver.Current.Profiler.Step(loggerType, profileName);
+            }
+            catch (InvalidOperationException)
+            {
+                //swallow this exception, it will occur if the ProfilerResolver is not initialized... generally only in 
+                // unit tests.
+            }
+            return null;
+        }
 	}
 }

src/Umbraco.Core/IO/FileSystemProviderAttribute.cs

@@ -5,12 +5,11 @@ using System.Text;
 using Umbraco.Core.CodeAnnotations;
 
 namespace Umbraco.Core.IO
-{
-	[UmbracoExperimentalFeature("http://issues.umbraco.org/issue/U4-1156", "Will be declared public after 4.10")]
+{	
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
-    internal class FileSystemProviderAttribute : Attribute
+    public class FileSystemProviderAttribute : Attribute
     {
-        public string Alias { get; set; }
+        public string Alias { get; private set; }
 
         public FileSystemProviderAttribute(string alias)
         {

src/Umbraco.Core/IO/FileSystemProviderConstants.cs

@@ -6,8 +6,7 @@ using Umbraco.Core.CodeAnnotations;
 
 namespace Umbraco.Core.IO
 {
-	[UmbracoExperimentalFeature("http://issues.umbraco.org/issue/U4-1156", "Will be declared public after 4.10")]
-    internal class FileSystemProvider
+    internal class FileSystemProviderConstants
     {
         public const string Media = "media";
     }

src/Umbraco.Core/IO/FileSystemProviderManager.cs

@@ -9,9 +9,8 @@ using Umbraco.Core.CodeAnnotations;
 using Umbraco.Core.Configuration;
 
 namespace Umbraco.Core.IO
-{
-	[UmbracoExperimentalFeature("http://issues.umbraco.org/issue/U4-1156", "Will be declared public after 4.10")]
-    internal class FileSystemProviderManager
+{	
+    public class FileSystemProviderManager
     {
         private readonly FileSystemProvidersSection _config;
 
@@ -28,7 +27,7 @@ namespace Umbraco.Core.IO
 
         #region Constructors
 
-        public FileSystemProviderManager()
+        internal FileSystemProviderManager()
         {
             _config = (FileSystemProvidersSection)ConfigurationManager.GetSection("FileSystemProviders");
         }
@@ -48,7 +47,15 @@ namespace Umbraco.Core.IO
 		private readonly ConcurrentDictionary<string, ProviderConstructionInfo> _providerLookup = new ConcurrentDictionary<string, ProviderConstructionInfo>();
 		private readonly ConcurrentDictionary<Type, string> _wrappedProviderLookup = new ConcurrentDictionary<Type, string>(); 
 
-        public IFileSystem GetFileSystemProvider(string alias)
+        /// <summary>
+        /// Returns the underlying (non-typed) file system provider for the alias specified
+        /// </summary>
+        /// <param name="alias"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// It is recommended to use the typed GetFileSystemProvider method instead to get a strongly typed provider instance.
+        /// </remarks>
+        public IFileSystem GetUnderlyingFileSystemProvider(string alias)
         {
 			//either get the constructor info from cache or create it and add to cache
 	        var ctorInfo = _providerLookup.GetOrAdd(alias, s =>
@@ -88,6 +95,11 @@ namespace Umbraco.Core.IO
 	        return fs;
         }
 
+        /// <summary>
+        /// Returns the strongly typed file system provider
+        /// </summary>
+        /// <typeparam name="TProviderTypeFilter"></typeparam>
+        /// <returns></returns>
         public TProviderTypeFilter GetFileSystemProvider<TProviderTypeFilter>()
 			where TProviderTypeFilter : FileSystemWrapper
         {
@@ -111,7 +123,7 @@ namespace Umbraco.Core.IO
 			        return attr.Alias;
 		        });
 			
-            var innerFs = GetFileSystemProvider(alias);
+            var innerFs = GetUnderlyingFileSystemProvider(alias);
 	        var outputFs = Activator.CreateInstance(typeof (TProviderTypeFilter), innerFs);
 	        return (TProviderTypeFilter)outputFs;
         }

src/Umbraco.Core/IO/IOHelper.cs

@@ -1,14 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
+using System.Globalization;
 using System.Reflection;
-using System.Text;
 using System.IO;
 using System.Configuration;
 using System.Web;
 using System.Text.RegularExpressions;
-using System.Xml;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 
@@ -37,7 +34,7 @@ namespace Umbraco.Core.IO
             if (virtualPath.StartsWith("~"))
                 retval = virtualPath.Replace("~", SystemDirectories.Root);
 
-            if (virtualPath.StartsWith("/") && !virtualPath.StartsWith(SystemDirectories.Root))
+            if (virtualPath.StartsWith("/") && virtualPath.StartsWith(SystemDirectories.Root) == false)
                 retval = SystemDirectories.Root + "/" + virtualPath.TrimStart('/');
 
             return retval;
@@ -68,11 +65,7 @@ namespace Umbraco.Core.IO
 						if (tag.Groups[1].Success)
 							url = tag.Groups[1].Value;
 
-						// The richtext editor inserts a slash in front of the url. That's why we need this little fix
-						//                if (url.StartsWith("/"))
-						//                    text = text.Replace(url, ResolveUrl(url.Substring(1)));
-						//                else
-						if (!String.IsNullOrEmpty(url))
+						if (string.IsNullOrEmpty(url) == false)
 						{
 							string resolvedUrl = (url.Substring(0, 1) == "/") ? ResolveUrl(url.Substring(1)) : ResolveUrl(url);
 							text = text.Replace(url, resolvedUrl);
@@ -97,19 +90,15 @@ namespace Umbraco.Core.IO
             if (useHttpContext && HttpContext.Current != null)
             {
                 //string retval;
-                if (!string.IsNullOrEmpty(path) && (path.StartsWith("~") || path.StartsWith(SystemDirectories.Root)))
+                if (string.IsNullOrEmpty(path) == false && (path.StartsWith("~") || path.StartsWith(SystemDirectories.Root)))
                     return System.Web.Hosting.HostingEnvironment.MapPath(path);
                 else
                     return System.Web.Hosting.HostingEnvironment.MapPath("~/" + path.TrimStart('/'));
             }
 
-			//var root = (!string.IsNullOrEmpty(System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath)) 
-			//    ? System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath.TrimEnd(IOHelper.DirSepChar) 
-			//    : getRootDirectorySafe();
-
         	var root = GetRootDirectorySafe();
         	var newPath = path.TrimStart('~', '/').Replace('/', IOHelper.DirSepChar);
-        	var retval = root + IOHelper.DirSepChar.ToString() + newPath;
+        	var retval = root + IOHelper.DirSepChar.ToString(CultureInfo.InvariantCulture) + newPath;
 
         	return retval;
         }
@@ -144,9 +133,9 @@ namespace Umbraco.Core.IO
         /// <returns>A value indicating whether the filepath is valid.</returns>
         internal static bool VerifyEditPath(string filePath, string validDir)
         {
-            if (!filePath.StartsWith(MapPath(SystemDirectories.Root)))
+            if (filePath.StartsWith(MapPath(SystemDirectories.Root)) == false)
                 filePath = MapPath(filePath);
-            if (!validDir.StartsWith(MapPath(SystemDirectories.Root)))
+            if (validDir.StartsWith(MapPath(SystemDirectories.Root)) == false)
                 validDir = MapPath(validDir);
 
             return filePath.StartsWith(validDir);
@@ -161,7 +150,7 @@ namespace Umbraco.Core.IO
         /// <exception cref="FileSecurityException">The filepath is invalid.</exception>
         internal static bool ValidateEditPath(string filePath, string validDir)
         {
-            if (!VerifyEditPath(filePath, validDir))
+            if (VerifyEditPath(filePath, validDir) == false)
                 throw new FileSecurityException(String.Format("The filepath '{0}' is not within an allowed directory for this type of files", filePath.Replace(MapPath(SystemDirectories.Root), "")));
             return true;
         }
@@ -177,9 +166,9 @@ namespace Umbraco.Core.IO
             foreach (var dir in validDirs)
             {
                 var validDir = dir;
-                if (!filePath.StartsWith(MapPath(SystemDirectories.Root)))
+                if (filePath.StartsWith(MapPath(SystemDirectories.Root)) == false)
                     filePath = MapPath(filePath);
-                if (!validDir.StartsWith(MapPath(SystemDirectories.Root)))
+                if (validDir.StartsWith(MapPath(SystemDirectories.Root)) == false)
                     validDir = MapPath(validDir);
 
                 if (filePath.StartsWith(validDir))
@@ -198,7 +187,7 @@ namespace Umbraco.Core.IO
         /// <exception cref="FileSecurityException">The filepath is invalid.</exception>
         internal static bool ValidateEditPath(string filePath, IEnumerable<string> validDirs)
         {
-            if (!VerifyEditPath(filePath, validDirs))
+            if (VerifyEditPath(filePath, validDirs) == false)
            throw new FileSecurityException(String.Format("The filepath '{0}' is not within an allowed directory for this type of files", filePath.Replace(MapPath(SystemDirectories.Root), "")));
             return true;
         }
@@ -211,7 +200,7 @@ namespace Umbraco.Core.IO
         /// <returns>A value indicating whether the filepath is valid.</returns>
         internal static bool VerifyFileExtension(string filePath, List<string> validFileExtensions)
         {
-            if (!filePath.StartsWith(MapPath(SystemDirectories.Root)))
+            if (filePath.StartsWith(MapPath(SystemDirectories.Root)) == false)
                 filePath = MapPath(filePath);
             var f = new FileInfo(filePath);
             
@@ -227,7 +216,7 @@ namespace Umbraco.Core.IO
         /// <exception cref="FileSecurityException">The filepath is invalid.</exception>
         internal static bool ValidateFileExtension(string filePath, List<string> validFileExtensions)
         {
-            if (!VerifyFileExtension(filePath, validFileExtensions))
+            if (VerifyFileExtension(filePath, validFileExtensions) == false)
                 throw new FileSecurityException(String.Format("The extension for the current file '{0}' is not of an allowed type for this editor. This is typically controlled from either the installed MacroEngines or based on configuration in /config/umbracoSettings.config", filePath.Replace(MapPath(SystemDirectories.Root), "")));
             return true;
         }
@@ -241,7 +230,7 @@ namespace Umbraco.Core.IO
         /// <returns></returns>
         internal static string GetRootDirectorySafe()
         {
-            if (!String.IsNullOrEmpty(_rootDir))
+            if (string.IsNullOrEmpty(_rootDir) == false)
             {
                 return _rootDir;
             }
@@ -250,12 +239,27 @@ namespace Umbraco.Core.IO
 			var uri = new Uri(codeBase);
 			var path = uri.LocalPath;
         	var baseDirectory = Path.GetDirectoryName(path);
-            _rootDir = baseDirectory.Substring(0, baseDirectory.LastIndexOf("bin") - 1);
+            if (string.IsNullOrEmpty(baseDirectory))
+                throw new Exception("No root directory could be resolved. Please ensure that your Umbraco solution is correctly configured.");
+
+            _rootDir = baseDirectory.Contains("bin")
+                           ? baseDirectory.Substring(0, baseDirectory.LastIndexOf("bin", StringComparison.OrdinalIgnoreCase) - 1)
+                           : baseDirectory;
 
             return _rootDir;
-
         }
 
+        /// <summary>
+        /// Allows you to overwrite RootDirectory, which would otherwise be resolved
+        /// automatically upon application start.
+        /// </summary>
+        /// <remarks>The supplied path should be the absolute path to the root of the umbraco site.</remarks>
+        /// <param name="rootPath"></param>
+        internal static void SetRootDirectory(string rootPath)
+	    {
+            _rootDir = rootPath;
+	    }
+
         /// <summary>
         /// Check to see if filename passed has any special chars in it and strips them to create a safe filename.  Used to overcome an issue when Umbraco is used in IE in an intranet environment.
         /// </summary>

src/Umbraco.Core/MacroPropertyTypeResolver.cs

@@ -1,34 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Umbraco.Core.Models;
-using Umbraco.Core.ObjectResolution;
-
-namespace Umbraco.Core
-{
-    /// <summary>
-    /// A resolver to return all <see cref="IMacroPropertyType"/> objects
-    /// </summary>
-    internal sealed class MacroPropertyTypeResolver : ManyObjectsResolverBase<MacroPropertyTypeResolver, IMacroPropertyType>
-    {
-        /// <summary>
-		/// Constructor
-		/// </summary>
-		/// <param name="macroPropertyTypes"></param>		
-        internal MacroPropertyTypeResolver(IEnumerable<Type> macroPropertyTypes)
-			: base(macroPropertyTypes)
-		{
-
-		}
-
-		/// <summary>
-		/// Gets the <see cref="IMacroPropertyType"/> implementations.
-		/// </summary>
-		public IEnumerable<IMacroPropertyType> MacroPropertyTypes
-		{
-			get
-			{
-				return Values;
-			}
-		}
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/ContentAll.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class ContentAll : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "contentAll"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "content"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.Int32; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/ContentPicker.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class ContentPicker : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "contentPicker"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "content"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.Int32; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/ContentRandom.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class ContentRandom : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "contentRandom"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "content"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.Int32; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/ContentStubs.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class ContentStubs : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "contentStubs"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "content"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.Int32; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/ContentTree.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class ContentTree : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "contentTree"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "content"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.Int32; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/ContentType.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class ContentType : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "contentType"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "contentTypeSingle"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.Int32; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/ContentTypeMultiple.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class ContentTypeMultiple : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "contentTypeMultiple"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "contentTypeMultiple"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.Int32; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/MediaCurrent.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class MediaCurrent : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "mediaCurrent"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "media"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.Int32; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/Number.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class Number : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "number"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "numeric"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.Int32; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/PropertyTypePicker.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class PropertyTypePicker : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "propertyTypePicker"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "propertyTypePicker"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.String; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/PropertyTypePickerMultiple.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class PropertyTypePickerMultiple : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "propertyTypePickerMultiple"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "propertyTypePickerMultiple"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.String; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/TabPicker.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class TabPicker : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "tabPicker"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "tabPicker"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.String; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/TabPickerMultiple.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class TabPickerMultiple : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "tabPickerMultiple"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "tabPickerMultiple"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.String; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/Text.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class Text : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "text"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "text"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.String; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/TextMultiLine.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class TextMultiLine : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "textMultiLine"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "textMultiple"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.String; }
-        }
-    }
-}

src/Umbraco.Core/Macros/PropertyTypes/YesNoBool.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Macros.PropertyTypes
-{
-    internal class YesNoBool : IMacroPropertyType
-    {
-        public string Alias
-        {
-            get { return "bool"; }
-        }
-
-        public string RenderingAssembly
-        {
-            get { return "umbraco.macroRenderings"; }
-        }
-
-        public string RenderingType
-        {
-            get { return "yesNo"; }
-        }
-
-        public MacroPropertyTypeBaseTypes BaseType
-        {
-            get { return MacroPropertyTypeBaseTypes.Boolean; }
-        }
-    }
-}

src/Umbraco.Core/Models/ContentType.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
-using Umbraco.Core.Persistence.Mappers;
 
 namespace Umbraco.Core.Models
 {
@@ -16,12 +15,22 @@ namespace Umbraco.Core.Models
     {
         private int _defaultTemplate;
         private IEnumerable<ITemplate> _allowedTemplates;
-
+        
+        /// <summary>
+        /// Constuctor for creating a ContentType with the parent's id.
+        /// </summary>
+        /// <remarks>You usually only want to use this for creating ContentTypes at the root.</remarks>
+        /// <param name="parentId"></param>
         public ContentType(int parentId) : base(parentId)
         {
             _allowedTemplates = new List<ITemplate>();
         }
 
+        /// <summary>
+        /// Constuctor for creating a ContentType with the parent as an inherited type.
+        /// </summary>
+        /// <remarks>Use this to ensure inheritance from parent.</remarks>
+        /// <param name="parent"></param>
 		public ContentType(IContentType parent) : base(parent)
 		{
 			_allowedTemplates = new List<ITemplate>();
@@ -152,14 +161,24 @@ namespace Umbraco.Core.Models
         {
             base.ResetDirtyProperties();
 
+            //loop through each property group to reset the property types
+            var propertiesReset = new List<int>();
+
             foreach (var propertyGroup in PropertyGroups)
             {
                 propertyGroup.ResetDirtyProperties();
                 foreach (var propertyType in propertyGroup.PropertyTypes)
-                {
+                {                    
                     propertyType.ResetDirtyProperties();
+                    propertiesReset.Add(propertyType.Id);
                 }
             }
+            //then loop through our property type collection since some might not exist on a property group
+            //but don't re-reset ones we've already done.
+            foreach (var propertyType in PropertyTypes.Where(x => propertiesReset.Contains(x.Id) == false))
+            {
+                propertyType.ResetDirtyProperties();
+            }
         }
 
         /// <summary>

src/Umbraco.Core/Models/ContentTypeCompositionBase.cs

@@ -20,8 +20,10 @@ namespace Umbraco.Core.Models
         {
         }
 
-		protected ContentTypeCompositionBase(IContentTypeBase parent) : base(parent)
+        protected ContentTypeCompositionBase(IContentTypeComposition parent)
+            : base(parent)
 		{
+		    AddContentType(parent);
 		}
 
         private static readonly PropertyInfo ContentTypeCompositionSelector =

src/Umbraco.Core/Models/EntityBase/Entity.cs

@@ -171,19 +171,6 @@ namespace Umbraco.Core.Models.EntityBase
             }
         }
 
-        public static bool operator ==(Entity left, Entity right)
-        {
-            if (ReferenceEquals(null, left))
-                return false;
-
-            return left.Equals(right);
-        }
-
-        public static bool operator !=(Entity left, Entity right)
-        {
-            return !(left == right);
-        }
-
         public virtual bool SameIdentityAs(IEntity other)
         {
             if (ReferenceEquals(null, other))

src/Umbraco.Core/Models/IMacro.cs

@@ -1,94 +0,0 @@
-using System.Collections.Generic;
-using System.Runtime.Serialization;
-using Umbraco.Core.Models.EntityBase;
-
-namespace Umbraco.Core.Models
-{
-    /// <summary>
-    /// Defines a Macro
-    /// </summary>
-    internal interface IMacro : IAggregateRoot
-    {
-        /// <summary>
-        /// Gets or sets the alias of the Macro
-        /// </summary>
-        [DataMember]
-        string Alias { get; set; }
-
-        /// <summary>
-        /// Gets or sets the name of the Macro
-        /// </summary>
-        [DataMember]
-        string Name { get; set; }
-
-        /// <summary>
-        /// Gets or sets a boolean indicating whether the Macro can be used in an Editor
-        /// </summary>
-        [DataMember]
-        bool UseInEditor { get; set; }
-
-        /// <summary>
-        /// Gets or sets the Cache Duration for the Macro
-        /// </summary>
-        [DataMember]
-        int CacheDuration { get; set; }
-
-        /// <summary>
-        /// Gets or sets a boolean indicating whether the Macro should be Cached by Page
-        /// </summary>
-        [DataMember]
-        bool CacheByPage { get; set; }
-
-        /// <summary>
-        /// Gets or sets a boolean indicating whether the Macro should be Cached Personally
-        /// </summary>
-        [DataMember]
-        bool CacheByMember { get; set; }
-
-        /// <summary>
-        /// Gets or sets a boolean indicating whether the Macro should be rendered in an Editor
-        /// </summary>
-        [DataMember]
-        bool DontRender { get; set; }
-
-        /// <summary>
-        /// Gets or sets the path to the script file in use
-        /// </summary>
-        /// <remarks>Optional: Can only be one of three Script, Python or Xslt</remarks>
-        [DataMember]
-        string ScriptFile { get; set; }
-
-        /// <summary>
-        /// Gets or sets the name of the assembly, which should be used by the Macro
-        /// </summary>
-        /// <remarks>Will usually only be filled if the ScriptFile is a Usercontrol</remarks>
-        [DataMember]
-        string ScriptAssembly { get; set; }
-
-        /// <summary>
-        /// Gets or set the path to the Python file in use
-        /// </summary>
-        /// <remarks>Optional: Can only be one of three Script, Python or Xslt</remarks>
-        [DataMember]
-        string Python { get; set; }
-
-        /// <summary>
-        /// Gets or sets the path to the Xslt file in use
-        /// </summary>
-        /// <remarks>Optional: Can only be one of three Script, Python or Xslt</remarks>
-        [DataMember]
-        string Xslt { get; set; }
-
-        /// <summary>
-        /// Gets or sets a list of Macro Properties
-        /// </summary>
-        [DataMember]
-        List<IMacroProperty> Properties { get; set; }
-
-        /// <summary>
-        /// Returns an enum <see cref="MacroTypes"/> based on the properties on the Macro
-        /// </summary>
-        /// <returns><see cref="MacroTypes"/></returns>
-        MacroTypes MacroType();
-    }
-}

src/Umbraco.Core/Models/IMacroProperty.cs

@@ -1,39 +0,0 @@
-using System.Runtime.Serialization;
-using Umbraco.Core.Models.EntityBase;
-
-namespace Umbraco.Core.Models
-{
-    /// <summary>
-    /// Defines a Property for a Macro
-    /// </summary>
-    internal interface IMacroProperty : IValueObject
-    {
-        /// <summary>
-        /// Gets or sets the Alias of the Property
-        /// </summary>
-        [DataMember]
-        string Alias { get; set; }
-
-        /// <summary>
-        /// Gets or sets the Name of the Property
-        /// </summary>
-        [DataMember]
-        string Name { get; set; }
-
-        /// <summary>
-        /// Gets or sets the Sort Order of the Property
-        /// </summary>
-        [DataMember]
-        int SortOrder { get; set; }
-
-        /// <summary>
-        /// Gets or sets the Type for this Property
-        /// </summary>
-        /// <remarks>
-        /// The MacroPropertyTypes acts as a plugin for Macros.
-        /// All types was previously contained in the database, but has been ported to code.
-        /// </remarks>
-        [DataMember]
-        IMacroPropertyType PropertyType { get; set; }
-    }
-}

src/Umbraco.Core/Models/IMacroPropertyType.cs

@@ -1,28 +0,0 @@
-namespace Umbraco.Core.Models
-{
-    /// <summary>
-    /// Defines a PropertyType (plugin) for a Macro
-    /// </summary>
-    internal interface IMacroPropertyType
-    {
-        /// <summary>
-        /// Gets the unique Alias of the Property Type
-        /// </summary>
-        string Alias { get; }
-
-        /// <summary>
-        /// Gets the name of the Assembly used to render the Property Type
-        /// </summary>
-        string RenderingAssembly { get; }
-        
-        /// <summary>
-        /// Gets the name of the Type used to render the Property Type
-        /// </summary>
-        string RenderingType { get; }
-        
-        /// <summary>
-        /// Gets the Base Type for storing the PropertyType (Int32, String, Boolean)
-        /// </summary>
-        MacroPropertyTypeBaseTypes BaseType { get; }
-    }
-}

src/Umbraco.Core/Models/IPublishedContent.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Diagnostics;
 
 namespace Umbraco.Core.Models
 {
@@ -10,7 +11,7 @@ namespace Umbraco.Core.Models
 	/// <remarks>
 	/// A replacement for INode which needs to occur since INode doesn't contain the document type alias
 	/// and INode is poorly formatted with mutable properties (i.e. Lists instead of IEnumerable)
-	/// </remarks>
+	/// </remarks>	
 	public interface IPublishedContent
 	{
 		int Id { get; }

src/Umbraco.Core/Models/Macro.cs

@@ -1,290 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Runtime.Serialization;
-using Umbraco.Core.Models.EntityBase;
-
-namespace Umbraco.Core.Models
-{
-    /// <summary>
-    /// Represents a Macro
-    /// </summary>
-    [Serializable]
-    [DataContract(IsReference = true)]
-    internal class Macro : Entity, IMacro
-    {
-        private string _alias;
-        private string _name;
-        private bool _useInEditor;
-        private int _cacheDuration;
-        private bool _cacheByPage;
-        private bool _cacheByMember;
-        private bool _dontRender;
-        private string _scriptFile;
-        private string _scriptAssembly;
-        private string _python;
-        private string _xslt;
-        private List<IMacroProperty> _properties;
-
-        private static readonly PropertyInfo AliasSelector = ExpressionHelper.GetPropertyInfo<Macro, string>(x => x.Alias);
-        private static readonly PropertyInfo NameSelector = ExpressionHelper.GetPropertyInfo<Macro, string>(x => x.Name);
-        private static readonly PropertyInfo UseInEditorSelector = ExpressionHelper.GetPropertyInfo<Macro, bool>(x => x.UseInEditor);
-        private static readonly PropertyInfo CacheDurationSelector = ExpressionHelper.GetPropertyInfo<Macro, int>(x => x.CacheDuration);
-        private static readonly PropertyInfo CacheByPageSelector = ExpressionHelper.GetPropertyInfo<Macro, bool>(x => x.CacheByPage);
-        private static readonly PropertyInfo CacheByMemberSelector = ExpressionHelper.GetPropertyInfo<Macro, bool>(x => x.CacheByMember);
-        private static readonly PropertyInfo DontRenderSelector = ExpressionHelper.GetPropertyInfo<Macro, bool>(x => x.DontRender);
-        private static readonly PropertyInfo ScriptFileSelector = ExpressionHelper.GetPropertyInfo<Macro, string>(x => x.ScriptFile);
-        private static readonly PropertyInfo ScriptAssemblySelector = ExpressionHelper.GetPropertyInfo<Macro, string>(x => x.ScriptAssembly);
-        private static readonly PropertyInfo PythonSelector = ExpressionHelper.GetPropertyInfo<Macro, string>(x => x.Python);
-        private static readonly PropertyInfo XsltSelector = ExpressionHelper.GetPropertyInfo<Macro, string>(x => x.Xslt);
-        private static readonly PropertyInfo PropertiesSelector = ExpressionHelper.GetPropertyInfo<Macro, List<IMacroProperty>>(x => x.Properties);
-
-        /// <summary>
-        /// Gets or sets the alias of the Macro
-        /// </summary>
-        [DataMember]
-        public string Alias
-        {
-            get { return _alias; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _alias = value;
-                    return _alias;
-                }, _alias, AliasSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the name of the Macro
-        /// </summary>
-        [DataMember]
-        public string Name
-        {
-            get { return _name; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _name = value;
-                    return _name;
-                }, _name, NameSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets a boolean indicating whether the Macro can be used in an Editor
-        /// </summary>
-        [DataMember]
-        public bool UseInEditor
-        {
-            get { return _useInEditor; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _useInEditor = value;
-                    return _useInEditor;
-                }, _useInEditor, UseInEditorSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the Cache Duration for the Macro
-        /// </summary>
-        [DataMember]
-        public int CacheDuration
-        {
-            get { return _cacheDuration; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _cacheDuration = value;
-                    return _cacheDuration;
-                }, _cacheDuration, CacheDurationSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets a boolean indicating whether the Macro should be Cached by Page
-        /// </summary>
-        [DataMember]
-        public bool CacheByPage
-        {
-            get { return _cacheByPage; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _cacheByPage = value;
-                    return _cacheByPage;
-                }, _cacheByPage, CacheByPageSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets a boolean indicating whether the Macro should be Cached Personally
-        /// </summary>
-        [DataMember]
-        public bool CacheByMember
-        {
-            get { return _cacheByMember; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _cacheByMember = value;
-                    return _cacheByMember;
-                }, _cacheByMember, CacheByMemberSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets a boolean indicating whether the Macro should be rendered in an Editor
-        /// </summary>
-        [DataMember]
-        public bool DontRender
-        {
-            get { return _dontRender; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _dontRender = value;
-                    return _dontRender;
-                }, _dontRender, DontRenderSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the path to the script file in use
-        /// </summary>
-        /// <remarks>Optional: Can only be one of three Script, Python or Xslt</remarks>
-        [DataMember]
-        public string ScriptFile
-        {
-            get { return _scriptFile; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _scriptFile = value;
-                    return _scriptFile;
-                }, _scriptFile, ScriptFileSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the name of the assembly, which should be used by the Macro
-        /// </summary>
-        /// <remarks>Will usually only be filled if the ScriptFile is a Usercontrol</remarks>
-        [DataMember]
-        public string ScriptAssembly
-        {
-            get { return _scriptAssembly; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _scriptAssembly = value;
-                    return _scriptAssembly;
-                }, _scriptAssembly, ScriptAssemblySelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or set the path to the Python file in use
-        /// </summary>
-        /// <remarks>Optional: Can only be one of three Script, Python or Xslt</remarks>
-        [DataMember]
-        public string Python
-        {
-            get { return _python; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _python = value;
-                    return _python;
-                }, _python, PythonSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the path to the Xslt file in use
-        /// </summary>
-        /// <remarks>Optional: Can only be one of three Script, Python or Xslt</remarks>
-        [DataMember]
-        public string Xslt
-        {
-            get { return _xslt; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _xslt = value;
-                    return _xslt;
-                }, _xslt, XsltSelector);
-            }
-        }
-
-        //TODO: This needs to be changed to a custom collection class so we can track the dirtyness of each property!
-        /// <summary>
-        /// Gets or sets a list of Macro Properties
-        /// </summary>
-        [DataMember]
-        public List<IMacroProperty> Properties
-        {
-            get { return _properties; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _properties = value;
-                    return _properties;
-                }, _properties, PropertiesSelector);
-            }
-        }
-
-        /// <summary>
-        /// Overridden this method in order to set a random Id
-        /// </summary>
-        internal override void AddingEntity()
-        {
-            base.AddingEntity();
-
-            var random = new Random();
-            Id = random.Next(10000, int.MaxValue);
-
-            Key = Alias.EncodeAsGuid();
-        }
-
-        /// <summary>
-        /// Returns an enum <see cref="MacroTypes"/> based on the properties on the Macro
-        /// </summary>
-        /// <returns><see cref="MacroTypes"/></returns>
-        public MacroTypes MacroType()
-        {
-            if (!string.IsNullOrEmpty(Xslt))
-                return MacroTypes.Xslt;
-            
-            if (!string.IsNullOrEmpty(Python))
-                return MacroTypes.Python;
-            
-            if (!string.IsNullOrEmpty(ScriptFile))
-                return MacroTypes.Script;
-            
-            if (!string.IsNullOrEmpty(ScriptFile) && ScriptFile.ToLower().IndexOf(".ascx", StringComparison.InvariantCultureIgnoreCase) > -1)
-            {
-                return MacroTypes.UserControl;
-            }
-            
-            if (!string.IsNullOrEmpty(ScriptFile) && !string.IsNullOrEmpty(ScriptAssembly))
-                return MacroTypes.CustomControl;
-
-            return MacroTypes.Unknown;
-        }
-    }
-}

src/Umbraco.Core/Models/MacroProperty.cs

@@ -1,98 +0,0 @@
-using System;
-using System.Reflection;
-using System.Runtime.Serialization;
-using Umbraco.Core.Models.EntityBase;
-
-namespace Umbraco.Core.Models
-{
-    /// <summary>
-    /// Represents a Macro Property
-    /// </summary>
-    [Serializable]
-    [DataContract(IsReference = true)]
-    internal class MacroProperty : TracksChangesEntityBase, IMacroProperty, IRememberBeingDirty
-    {
-        private string _alias;
-        private string _name;
-        private int _sortOrder;
-        private IMacroPropertyType _propertyType;
-
-        private static readonly PropertyInfo AliasSelector = ExpressionHelper.GetPropertyInfo<MacroProperty, string>(x => x.Alias);
-        private static readonly PropertyInfo NameSelector = ExpressionHelper.GetPropertyInfo<MacroProperty, string>(x => x.Name);
-        private static readonly PropertyInfo SortOrderSelector = ExpressionHelper.GetPropertyInfo<MacroProperty, int>(x => x.SortOrder);
-        private static readonly PropertyInfo PropertyTypeSelector = ExpressionHelper.GetPropertyInfo<MacroProperty, IMacroPropertyType>(x => x.PropertyType);
-
-        /// <summary>
-        /// Gets or sets the Alias of the Property
-        /// </summary>
-        [DataMember]
-        public string Alias
-        {
-            get { return _alias; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _alias = value;
-                    return _alias;
-                }, _alias, AliasSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the Name of the Property
-        /// </summary>
-        [DataMember]
-        public string Name
-        {
-            get { return _name; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _name = value;
-                    return _name;
-                }, _name, NameSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the Sort Order of the Property
-        /// </summary>
-        [DataMember]
-        public int SortOrder
-        {
-            get { return _sortOrder; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _sortOrder = value;
-                    return _sortOrder;
-                }, _sortOrder, SortOrderSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the Type for this Property
-        /// </summary>
-        /// <remarks>
-        /// The MacroPropertyTypes acts as a plugin for Macros.
-        /// All types was previously contained in the database, but has been ported to code.
-        /// </remarks>
-        [DataMember]
-        public IMacroPropertyType PropertyType
-
-        {
-            get { return _propertyType; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _propertyType = value;
-                    return _propertyType;
-                }, _propertyType, PropertyTypeSelector);
-            }
-        }
-    }
-}

src/Umbraco.Core/Models/MacroPropertyTypeBaseTypes.cs

@@ -1,20 +0,0 @@
-using System;
-using System.Runtime.Serialization;
-
-namespace Umbraco.Core.Models
-{
-    /// <summary>
-    /// Enum for the three allowed BaseTypes
-    /// </summary>
-    [Serializable]
-    [DataContract(IsReference = true)]
-    internal enum MacroPropertyTypeBaseTypes
-    {
-        [EnumMember]
-        Int32,
-        [EnumMember]
-        Boolean,
-        [EnumMember]
-        String
-    }
-}

src/Umbraco.Core/Models/MacroTypes.cs

@@ -1,26 +0,0 @@
-using System;
-using System.Runtime.Serialization;
-
-namespace Umbraco.Core.Models
-{
-    /// <summary>
-    /// Enum for the various types of Macros
-    /// </summary>
-    [Serializable]
-    [DataContract(IsReference = true)]
-    internal enum MacroTypes
-    {
-        [EnumMember]
-        Xslt = 1,
-        [EnumMember]
-        CustomControl = 2,
-        [EnumMember]
-        UserControl = 3,
-        [EnumMember]
-        Unknown = 4,
-        [EnumMember]
-        Python = 5,
-        [EnumMember]
-        Script = 6
-    }
-}

src/Umbraco.Core/Models/MediaType.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Runtime.Serialization;
-using Umbraco.Core.Persistence.Mappers;
 
 namespace Umbraco.Core.Models
 {
@@ -11,10 +10,20 @@ namespace Umbraco.Core.Models
     [DataContract(IsReference = true)]
     public class MediaType : ContentTypeCompositionBase, IMediaType
     {
+        /// <summary>
+        /// Constuctor for creating a MediaType with the parent's id.
+        /// </summary>
+        /// <remarks>You usually only want to use this for creating MediaTypes at the root.</remarks>
+        /// <param name="parentId"></param>
         public MediaType(int parentId) : base(parentId)
         {
         }
 
+        /// <summary>
+        /// Constuctor for creating a MediaType with the parent as an inherited type.
+        /// </summary>
+        /// <remarks>Use this to ensure inheritance from parent.</remarks>
+        /// <param name="parent"></param>
 		public MediaType(IMediaType parent) : base(parent)
 		{
 		}

src/Umbraco.Core/Models/Membership/UmbracoMembershipUser.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Web.Security;
+
+namespace Umbraco.Core.Models.Membership
+{
+    internal class UmbracoMembershipUser<T> : MembershipUser where T : IMembershipUser
+    {
+        private T _user;
+
+        #region Constructors
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UmbracoMembershipUser{T}"/> class.
+        /// </summary>
+        public UmbracoMembershipUser(T user)
+        {
+            _user = user;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UmbracoMembershipUser{T}"/> class.
+        /// </summary>
+        /// <param name="providerName">Name of the provider.</param>
+        /// <param name="name">The name.</param>
+        /// <param name="providerUserKey">The provider user key.</param>
+        /// <param name="email">The email.</param>
+        /// <param name="passwordQuestion">The password question.</param>
+        /// <param name="comment">The comment.</param>
+        /// <param name="isApproved">if set to <c>true</c> [is approved].</param>
+        /// <param name="isLockedOut">if set to <c>true</c> [is locked out].</param>
+        /// <param name="creationDate">The creation date.</param>
+        /// <param name="lastLoginDate">The last login date.</param>
+        /// <param name="lastActivityDate">The last activity date.</param>
+        /// <param name="lastPasswordChangedDate">The last password changed date.</param>
+        /// <param name="lastLockoutDate">The last lockout date.</param>
+        /// <param name="fullName">The full name.</param>
+        /// <param name="language">The language.</param>
+        /// <param name="userType">Type of the user.</param>
+        /// <param name="user"></param>
+        public UmbracoMembershipUser(string providerName, string name, object providerUserKey, string email, 
+            string passwordQuestion, string comment, bool isApproved, bool isLockedOut, 
+            DateTime creationDate, DateTime lastLoginDate, DateTime lastActivityDate, DateTime lastPasswordChangedDate,
+            DateTime lastLockoutDate, string fullName, string language, IUserType userType, T user) 
+            : base( providerName, name, providerUserKey, email, passwordQuestion, comment, isApproved, isLockedOut, 
+                creationDate, lastLoginDate, lastActivityDate, lastPasswordChangedDate, lastLockoutDate)
+        {
+            _user = user;
+        }
+
+        #endregion
+    }
+}

src/Umbraco.Core/Models/PropertyType.cs

@@ -14,7 +14,6 @@ namespace Umbraco.Core.Models
     [DataContract(IsReference = true)]
     public class PropertyType : Entity, IEquatable<PropertyType>
     {
-        //private SerializationService _service;
         private string _name;
         private string _alias;
         private string _description;
@@ -34,22 +33,12 @@ namespace Umbraco.Core.Models
 
             DataTypeId = dataTypeDefinition.ControlId;
             DataTypeDatabaseType = dataTypeDefinition.DatabaseType;
-
-            EnsureSerializationService();
         }
 
         internal PropertyType(Guid dataTypeControlId, DataTypeDatabaseType dataTypeDatabaseType)
         {
             DataTypeId = dataTypeControlId;
             DataTypeDatabaseType = dataTypeDatabaseType;
-
-            EnsureSerializationService();
-        }
-
-        private void EnsureSerializationService()
-        {
-            /*var serviceStackSerializer = new ServiceStackXmlSerializer();
-            _service = new SerializationService(serviceStackSerializer);*/
         }
 
         private static readonly PropertyInfo NameSelector = ExpressionHelper.GetPropertyInfo<PropertyType, string>(x => x.Name);
@@ -206,6 +195,7 @@ namespace Umbraco.Core.Models
         /// Gets of Sets the Help text for the current PropertyType
         /// </summary>
         [DataMember]
+        [Obsolete("Not used anywhere in the UI")]
         public string HelpText
         {
             get { return _helpText; }
@@ -240,7 +230,7 @@ namespace Umbraco.Core.Models
         /// Gets or Sets the RegEx for validation of legacy DataTypes
         /// </summary>
         [DataMember]
-        internal string ValidationRegExp
+        public string ValidationRegExp
         {
             get { return _validationRegExp; }
             set
@@ -252,7 +242,6 @@ namespace Umbraco.Core.Models
                 }, _validationRegExp, ValidationRegExpSelector);
             }
         }
-        //Note that Validation should eventually come from PropertyEditors like in v5
 
         /// <summary>
         /// Create a new Property object from a "raw" database value.

src/Umbraco.Core/Models/Rdbms/ContentTypeAllowedContentTypeDto.cs

@@ -20,5 +20,8 @@ namespace Umbraco.Core.Models.Rdbms
         [Column("SortOrder")]
         [Constraint(Name = "df_cmsContentTypeAllowedContentType_sortOrder", Default = "0")]
         public int SortOrder { get; set; }
+
+        [ResultColumn]
+        public ContentTypeDto ContentTypeDto { get; set; }
     }
 }

src/Umbraco.Core/Models/ServerRegistration.cs

@@ -94,5 +94,10 @@ namespace Umbraco.Core.Models
                 }, _isActive, IsActiveSelector);
             }
         }
+
+        public override string ToString()
+        {
+            return "(" + ServerAddress + ", " + ComputerName + ", IsActive = " + IsActive + ")";
+        }
     }
 }

src/Umbraco.Core/Models/Template.cs

@@ -45,12 +45,8 @@ namespace Umbraco.Core.Models
         {
             base.Path = path;
             ParentId = -1;
-            Key = name.EncodeAsGuid();
             _name = name.Replace("/", ".").Replace("\\", "");
             _alias = alias.ToSafeAlias();
-
-            CreateDate = DateTime.Now;
-            UpdateDate = DateTime.Now;
         }
 
         [DataMember]
@@ -199,5 +195,17 @@ namespace Umbraco.Core.Models
 
             return validFile && validExtension;
         }
+
+        /// <summary>
+        /// Method to call when Entity is being saved
+        /// </summary>
+        /// <remarks>Created date is set and a Unique key is assigned</remarks>
+        internal override void AddingEntity()
+        {
+            base.AddingEntity();
+
+            if (Key == Guid.Empty)
+                Key = Guid.NewGuid();
+        }
     }
 }

src/Umbraco.Core/Models/UmbracoEntity.cs

@@ -171,7 +171,7 @@ namespace Umbraco.Core.Models
 
         public bool IsDraft
         {
-            get { return _isPublished; }
+            get { return _isDraft; }
             set
             {
                 SetPropertyValueAndDetectChanges(o =>

src/Umbraco.Core/ObjectExtensions.cs

@@ -14,7 +14,7 @@ using System.Xml;
 
 namespace Umbraco.Core
 {
-	internal static class ObjectExtensions
+	public static class ObjectExtensions
 	{
 		
 		//private static readonly ConcurrentDictionary<Type, Func<object>> ObjectFactoryCache = new ConcurrentDictionary<Type, Func<object>>();
@@ -36,7 +36,7 @@ namespace Umbraco.Core
 		/// <typeparam name="T"></typeparam>
 		/// <param name="input">The input.</param>
 		/// <returns></returns>
-		public static T SafeCast<T>(this object input)
+		internal static T SafeCast<T>(this object input)
 		{
 			if (ReferenceEquals(null, input) || ReferenceEquals(default(T), input)) return default(T);
 			if (input is T) return (T)input;
@@ -165,7 +165,7 @@ namespace Umbraco.Core
 			return Attempt<object>.False;
 		}
 
-		public static void CheckThrowObjectDisposed(this IDisposable disposable, bool isDisposed, string objectname)
+		internal static void CheckThrowObjectDisposed(this IDisposable disposable, bool isDisposed, string objectname)
 		{
 			//TODO: Localise this exception
 			if (isDisposed)
@@ -246,7 +246,7 @@ namespace Umbraco.Core
 		/// <param name="o"></param>
 		/// <param name="ignoreProperties"></param>
 		/// <returns></returns>
-		public static IDictionary<string, TVal> ToDictionary<T, TProperty, TVal>(this T o,
+        internal static IDictionary<string, TVal> ToDictionary<T, TProperty, TVal>(this T o,
 																				 params Expression<Func<T, TProperty>>[] ignoreProperties)
 		{
 			return o.ToDictionary<TVal>(ignoreProperties.Select(e => o.GetPropertyInfo(e)).Select(propInfo => propInfo.Name).ToArray());
@@ -258,7 +258,7 @@ namespace Umbraco.Core
 		/// <param name="o"></param>
 		/// <param name="ignoreProperties">Properties to ignore</param>
 		/// <returns></returns>
-		public static IDictionary<string, TVal> ToDictionary<TVal>(this object o, params string[] ignoreProperties)
+		internal static IDictionary<string, TVal> ToDictionary<TVal>(this object o, params string[] ignoreProperties)
 		{
 			if (o != null)
 			{
@@ -277,7 +277,7 @@ namespace Umbraco.Core
 			return new Dictionary<string, TVal>();
 		}
 
-		public static string ToDebugString(this object obj, int levels = 0)
+		internal static string ToDebugString(this object obj, int levels = 0)
 		{
 			if (obj == null) return "{null}";
 			try
@@ -346,7 +346,7 @@ namespace Umbraco.Core
 		/// <param name="value"></param>
 		/// <param name="type"></param>
 		/// <returns></returns>
-		public static Attempt<string> TryConvertToXmlString(this object value, Type type)
+		internal static Attempt<string> TryConvertToXmlString(this object value, Type type)
 		{
 			try
 			{
@@ -365,7 +365,7 @@ namespace Umbraco.Core
 		/// <param name="value"></param>
 		/// <param name="type">The Type can only be a primitive type or Guid and byte[] otherwise an exception is thrown</param>
 		/// <returns></returns>
-		public static string ToXmlString(this object value, Type type)
+		internal static string ToXmlString(this object value, Type type)
 		{
 			if (type == typeof(string)) return ((string)value).IsNullOrWhiteSpace() ? "" : (string)value;
 			if (type == typeof(bool)) return XmlConvert.ToString((bool)value);

src/Umbraco.Core/ObjectResolution/ApplicationEventsResolver.cs

@@ -45,7 +45,7 @@ namespace Umbraco.Core.ObjectResolution
         /// <summary>
         /// Create instances of all of the legacy startup handlers
         /// </summary>
-	    public void InstantiateLegacyStartupHanlders()
+	    public void InstantiateLegacyStartupHandlers()
 	    {
             //this will instantiate them all
 	        var handlers = _legacyResolver.LegacyStartupHandlers;

src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs

@@ -170,7 +170,7 @@ namespace Umbraco.Core.ObjectResolution
 			get
 			{
 				// ensure we can
-				if (!CanResolveBeforeFrozen)
+				if (CanResolveBeforeFrozen == false)
 					Resolution.EnsureIsFrozen();
 
 				// note: we apply .ToArray() to the output of CreateInstance() because that is an IEnumerable that

src/Umbraco.Core/ObjectResolution/ResolverBase.cs

@@ -13,7 +13,7 @@ namespace Umbraco.Core.ObjectResolution
             //add itself to the internal collection
             ResolverCollection.Add(this, resetAction);
         }
-        
+
     }
 
 	/// <summary>

src/Umbraco.Core/ObjectResolution/SingleObjectResolverBase.cs

@@ -69,6 +69,12 @@ namespace Umbraco.Core.ObjectResolution
 
 		#endregion
 
+        /// <summary>
+        /// Gets or sets a value indicating whether the resolver can resolve objects before resolution is frozen.
+        /// </summary>
+        /// <remarks>This is false by default and is used for some special internal resolvers.</remarks>
+        internal bool CanResolveBeforeFrozen { get; set; }
+
 		/// <summary>
 		/// Gets a value indicating whether the resolved object instance can be null.
 		/// </summary>
@@ -96,7 +102,10 @@ namespace Umbraco.Core.ObjectResolution
 		{
 			get
 			{
-				Resolution.EnsureIsFrozen();
+                // ensure we can
+                if (CanResolveBeforeFrozen == false)
+                    Resolution.EnsureIsFrozen();
+
 				using (new ReadLock(_lock))
 				{
 					if (!_canBeNull && _value == null)

src/Umbraco.Core/Packaging/DefaultPackageContext.cs

@@ -0,0 +1,45 @@
+using System;
+using NuGet;
+using Umbraco.Core.Configuration;
+
+namespace Umbraco.Core.Packaging
+{
+    internal class DefaultPackageContext : IPackageContext
+    {
+        public DefaultPackageContext(Func<string, string> mapPath)
+        {}
+
+        private readonly string _localPackageRepoFolderPath;
+        private readonly string _pluginInstallFolderPath;
+        private readonly Lazy<IPackageManager> _localPackageManager;
+        private readonly Lazy<IPackageRepository> _localPackageRepository;
+        private readonly Lazy<IPackageManager> _publicPackageManager;
+        private readonly Lazy<IPackageManager> _privatePackageManager;
+        private readonly Lazy<IPackageRepository> _publicPackageRepository;
+        private readonly Lazy<IPackageRepository> _sprivatePackageRepository;
+
+        /// <summary>
+        /// Gets the local path resolver.
+        /// </summary>
+        public IPackagePathResolver LocalPathResolver
+        {
+            get { return ((PackageManager)LocalPackageManager).PathResolver; }
+        }
+
+        /// <summary>
+        /// Gets the local package manager.
+        /// </summary>
+        public IPackageManager LocalPackageManager
+        {
+            get { return _localPackageManager.Value; }
+        }
+
+        /// <summary>
+        /// Gets the public package manager.
+        /// </summary>
+        public IPackageManager PublicPackageManager
+        {
+            get { return _publicPackageManager.Value; }
+        }
+    }
+}

src/Umbraco.Core/Packaging/IPackageContext.cs

@@ -0,0 +1,11 @@
+using NuGet;
+
+namespace Umbraco.Core.Packaging
+{
+    internal interface IPackageContext
+    {
+        IPackageManager LocalPackageManager { get; }
+        IPackageManager PublicPackageManager { get; }
+        IPackagePathResolver LocalPathResolver { get; } 
+    }
+}

src/Umbraco.Core/Persistence/DefaultDatabaseFactory.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Web;
 using Umbraco.Core.Configuration;
 
@@ -16,7 +17,12 @@ namespace Umbraco.Core.Persistence
 		private readonly string _connectionStringName;
         private readonly string _connectionString;
 		private readonly string _providerName;
-		private static volatile UmbracoDatabase _globalInstance = null;
+        
+        //very important to have ThreadStatic:
+        // see: http://issues.umbraco.org/issue/U4-2172
+        [ThreadStatic]
+        private static volatile UmbracoDatabase _nonHttpInstance;
+
 		private static readonly object Locker = new object();
 
 		/// <summary>
@@ -55,29 +61,27 @@ namespace Umbraco.Core.Persistence
 			//no http context, create the singleton global object
 			if (HttpContext.Current == null)
 			{
-				if (_globalInstance == null)
+                if (_nonHttpInstance == null)
 				{
 					lock (Locker)
 					{
 						//double check
-						if (_globalInstance == null)
+                        if (_nonHttpInstance == null)
 						{
-						    _globalInstance = string.IsNullOrEmpty(_connectionString) == false &&
-						                      string.IsNullOrEmpty(_providerName) == false
+                            _nonHttpInstance = string.IsNullOrEmpty(_connectionString) == false && string.IsNullOrEmpty(_providerName) == false
 						                          ? new UmbracoDatabase(_connectionString, _providerName)
 						                          : new UmbracoDatabase(_connectionStringName);
 						}
 					}
 				}
-				return _globalInstance;
+                return _nonHttpInstance;
 			}
 
 			//we have an http context, so only create one per request
-			if (!HttpContext.Current.Items.Contains(typeof(DefaultDatabaseFactory)))
+			if (HttpContext.Current.Items.Contains(typeof(DefaultDatabaseFactory)) == false)
 			{
 			    HttpContext.Current.Items.Add(typeof (DefaultDatabaseFactory),
-			                                  string.IsNullOrEmpty(_connectionString) == false &&
-			                                  string.IsNullOrEmpty(_providerName) == false
+			                                  string.IsNullOrEmpty(_connectionString) == false && string.IsNullOrEmpty(_providerName) == false
 			                                      ? new UmbracoDatabase(_connectionString, _providerName)
 			                                      : new UmbracoDatabase(_connectionStringName));
 			}
@@ -88,7 +92,7 @@ namespace Umbraco.Core.Persistence
 		{
 			if (HttpContext.Current == null)
 			{
-				_globalInstance.Dispose();
+                _nonHttpInstance.Dispose();
 			}
 			else
 			{

src/Umbraco.Core/Persistence/Factories/ContentFactory.cs

@@ -51,7 +51,8 @@ namespace Umbraco.Core.Persistence.Factories
                 UpdateDate = dto.ContentVersionDto.VersionDate,
                 ExpireDate = dto.ExpiresDate.HasValue ? dto.ExpiresDate.Value : (DateTime?)null,
                 ReleaseDate = dto.ReleaseDate.HasValue ? dto.ReleaseDate.Value : (DateTime?)null,
-                Version = dto.ContentVersionDto.VersionId
+                Version = dto.ContentVersionDto.VersionId,
+                PublishedState = dto.Published ? PublishedState.Published : PublishedState.Unpublished
             };
             //on initial construction we don't want to have dirty properties tracked
             // http://issues.umbraco.org/issue/U4-1946

src/Umbraco.Core/Persistence/Factories/PropertyFactory.cs

@@ -11,6 +11,8 @@ namespace Umbraco.Core.Persistence.Factories
         private readonly IContentTypeComposition _contentType;
         private readonly Guid _version;
         private readonly int _id;
+        private readonly DateTime _createDate;
+        private readonly DateTime _updateDate;
 
         public PropertyFactory(IContentTypeComposition contentType, Guid version, int id)
         {
@@ -19,6 +21,15 @@ namespace Umbraco.Core.Persistence.Factories
             _id = id;
         }
 
+        public PropertyFactory(IContentTypeComposition contentType, Guid version, int id, DateTime createDate, DateTime updateDate)
+        {
+            _contentType = contentType;
+            _version = version;
+            _id = id;
+            _createDate = createDate;
+            _updateDate = updateDate;
+        }
+
         #region Implementation of IEntityFactory<IContent,PropertyDataDto>
 
         public IEnumerable<Property> BuildEntity(IEnumerable<PropertyDataDto> dtos)
@@ -34,6 +45,8 @@ namespace Umbraco.Core.Persistence.Factories
                                                                              propertyDataDto.VersionId.Value,
                                                                              propertyDataDto.Id);
                 //on initial construction we don't want to have dirty properties tracked
+                property.CreateDate = _createDate;
+                property.UpdateDate = _updateDate;
                 // http://issues.umbraco.org/issue/U4-1946
                 property.ResetDirtyProperties(false);
                 properties.Add(property);

src/Umbraco.Core/Persistence/Factories/PropertyGroupFactory.cs

@@ -9,12 +9,21 @@ namespace Umbraco.Core.Persistence.Factories
     internal class PropertyGroupFactory : IEntityFactory<IEnumerable<PropertyGroup>, IEnumerable<PropertyTypeGroupDto>>
     {
         private readonly int _id;
+        private readonly DateTime _createDate;
+        private readonly DateTime _updateDate;
 
         public PropertyGroupFactory(int id)
         {
             _id = id;
         }
 
+        public PropertyGroupFactory(int id, DateTime createDate, DateTime updateDate)
+        {
+            _id = id;
+            _createDate = createDate;
+            _updateDate = updateDate;
+        }
+
         #region Implementation of IEntityFactory<IEnumerable<PropertyGroup>,IEnumerable<TabDto>>
 
         public IEnumerable<PropertyGroup> BuildEntity(IEnumerable<PropertyTypeGroupDto> dto)
@@ -58,7 +67,9 @@ namespace Umbraco.Core.Persistence.Factories
                                                     Mandatory = typeDto.Mandatory,
                                                     SortOrder = typeDto.SortOrder,
                                                     ValidationRegExp = typeDto.ValidationRegExp,
-                                                    PropertyGroupId = new Lazy<int>(() => tempGroupDto.Id)
+                                                    PropertyGroupId = new Lazy<int>(() => tempGroupDto.Id),
+                                                    CreateDate = _createDate,
+                                                    UpdateDate = _updateDate
                                                 };
                     //on initial construction we don't want to have dirty properties tracked
                     // http://issues.umbraco.org/issue/U4-1946

src/Umbraco.Core/Persistence/Factories/UmbracoEntityFactory.cs

@@ -28,12 +28,9 @@ namespace Umbraco.Core.Persistence.Factories
                                  UmbracoFile = dto.UmbracoFile ?? string.Empty
                              };
 
-            entity.IsPublished = dto.PublishedVersion != default(Guid) ||
-                                 (dto.NewestVersion != default(Guid) && dto.PublishedVersion == dto.NewestVersion);
-            entity.IsDraft = dto.NewestVersion != default(Guid) &&
-                             (dto.PublishedVersion == default(Guid) || dto.PublishedVersion != dto.NewestVersion);
-            entity.HasPendingChanges = dto.PublishedVersion != default(Guid) && dto.NewestVersion != default(Guid) &&
-                                       dto.PublishedVersion != dto.NewestVersion;
+            entity.IsPublished = dto.PublishedVersion != default(Guid) || (dto.NewestVersion != default(Guid) && dto.PublishedVersion == dto.NewestVersion);
+            entity.IsDraft = dto.NewestVersion != default(Guid) && (dto.PublishedVersion == default(Guid) || dto.PublishedVersion != dto.NewestVersion);
+            entity.HasPendingChanges = (dto.PublishedVersion != default(Guid) && dto.NewestVersion != default(Guid)) && dto.PublishedVersion != dto.NewestVersion;
 
             return entity;
         }

src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs

@@ -55,27 +55,29 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                                                                               {34, typeof (TaskTypeDto)},
                                                                               {35, typeof (TaskDto)},
                                                                               {36, typeof (ContentType2ContentTypeDto)},
-                                                                              {
-                                                                                  37,
-                                                                                  typeof (ContentTypeAllowedContentTypeDto)
-                                                                              },
+                                                                              {37, typeof (ContentTypeAllowedContentTypeDto)},
                                                                               {38, typeof (User2AppDto)},
                                                                               {39, typeof (User2NodeNotifyDto)},
                                                                               {40, typeof (User2NodePermissionDto)},
                                                                               {41, typeof (ServerRegistrationDto)}
                                                                           };
         #endregion
-
+        
         /// <summary>
         /// Drops all Umbraco tables in the db
         /// </summary>
         internal void UninstallDatabaseSchema()
         {
+            LogHelper.Info<DatabaseSchemaCreation>("Start UninstallDatabaseSchema");
+
             foreach (var item in OrderedTables.OrderByDescending(x => x.Key))
             {
                 var tableNameAttribute = item.Value.FirstAttribute<TableNameAttribute>();
+
                 string tableName = tableNameAttribute == null ? item.Value.Name : tableNameAttribute.Value;
 
+                LogHelper.Info<DatabaseSchemaCreation>("Uninstall" + tableName);
+
                 try
                 {
                     _database.DropTable(tableName);

src/Umbraco.Core/Persistence/Querying/ModelToSqlExpressionHelper.cs

@@ -455,9 +455,12 @@ namespace Umbraco.Core.Persistence.Querying
             if (fieldType == typeof(decimal))
                 return ((decimal)value).ToString(CultureInfo.InvariantCulture);
 
-            if(fieldType == typeof(DateTime))
+            if (fieldType == typeof(DateTime))
                 return "'" + EscapeParam(((DateTime)value).ToString(CultureInfo.InvariantCulture)) + "'";
-
+            
+            if (fieldType == typeof(bool))
+                return ((bool)value) ? Convert.ToString(1, CultureInfo.InvariantCulture) : Convert.ToString(0, CultureInfo.InvariantCulture);
+            
             return ShouldQuoteValue(fieldType)
                     ? "'" + EscapeParam(value) + "'"
                     : value.ToString();

src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs

@@ -401,6 +401,24 @@ namespace Umbraco.Core.Persistence.Repositories
 
         #region Implementation of IContentRepository
 
+        public IEnumerable<IContent> GetByPublishedVersion(IQuery<IContent> query)
+        {
+            var sqlClause = GetBaseQuery(false);
+            var translator = new SqlTranslator<IContent>(sqlClause, query);
+            var sql = translator.Translate()
+                                .Where<DocumentDto>(x => x.Published)
+                                .OrderByDescending<ContentVersionDto>(x => x.VersionDate)
+                                .OrderBy<NodeDto>(x => x.SortOrder);
+
+            //NOTE: This doesn't allow properties to be part of the query
+            var dtos = Database.Fetch<DocumentDto, ContentVersionDto, ContentDto, NodeDto>(sql);
+
+            foreach (var dto in dtos)
+            {
+                yield return CreateContentFromDto(dto, dto.VersionId);
+            }
+        }
+
         public IContent GetByLanguage(int id, string language)
         {
             var sql = GetBaseQuery(false);
@@ -437,7 +455,7 @@ namespace Umbraco.Core.Persistence.Repositories
                 content.Template = _templateRepository.Get(dto.TemplateId.Value);
             }
 
-            content.Properties = GetPropertyCollection(dto.NodeId, versionId, contentType);
+            content.Properties = GetPropertyCollection(dto.NodeId, versionId, contentType, content.CreateDate, content.UpdateDate);
 
             //on initial construction we don't want to have dirty properties tracked
             // http://issues.umbraco.org/issue/U4-1946
@@ -445,7 +463,7 @@ namespace Umbraco.Core.Persistence.Repositories
             return content;
         }
 
-        private PropertyCollection GetPropertyCollection(int id, Guid versionId, IContentType contentType)
+        private PropertyCollection GetPropertyCollection(int id, Guid versionId, IContentType contentType, DateTime createDate, DateTime updateDate)
         {
             var sql = new Sql();
             sql.Select("*")
@@ -456,7 +474,7 @@ namespace Umbraco.Core.Persistence.Repositories
                 .Where<PropertyDataDto>(x => x.VersionId == versionId);
 
             var propertyDataDtos = Database.Fetch<PropertyDataDto, PropertyTypeDto>(sql);
-            var propertyFactory = new PropertyFactory(contentType, versionId, id);
+            var propertyFactory = new PropertyFactory(contentType, versionId, id, createDate, updateDate);
             var properties = propertyFactory.BuildEntity(propertyDataDtos);
 
             var newProperties = properties.Where(x => x.HasIdentity == false);

src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs

@@ -320,13 +320,15 @@ namespace Umbraco.Core.Persistence.Repositories
             var sql = new Sql();
             sql.Select("*")
                .From<ContentTypeAllowedContentTypeDto>()
+               .LeftJoin<ContentTypeDto>()
+               .On<ContentTypeAllowedContentTypeDto, ContentTypeDto>(left => left.Id, right => right.NodeId)
                .Where<ContentTypeAllowedContentTypeDto>(x => x.Id == id);
 
-            var allowedContentTypeDtos = Database.Fetch<ContentTypeAllowedContentTypeDto>(sql);
-            return allowedContentTypeDtos.Select(x => new ContentTypeSort { Id = new Lazy<int>(() => x.AllowedId), SortOrder = x.SortOrder }).ToList();
+            var allowedContentTypeDtos = Database.Fetch<ContentTypeAllowedContentTypeDto, ContentTypeDto>(sql);
+            return allowedContentTypeDtos.Select(x => new ContentTypeSort { Id = new Lazy<int>(() => x.AllowedId), Alias = x.ContentTypeDto.Alias, SortOrder = x.SortOrder }).ToList();
         }
 
-        protected PropertyGroupCollection GetPropertyGroupCollection(int id)
+        protected PropertyGroupCollection GetPropertyGroupCollection(int id, DateTime createDate, DateTime updateDate)
         {
             var sql = new Sql();
             sql.Select("*")
@@ -340,12 +342,12 @@ namespace Umbraco.Core.Persistence.Repositories
 
             var dtos = Database.Fetch<PropertyTypeGroupDto, PropertyTypeDto, DataTypeDto, PropertyTypeGroupDto>(new GroupPropertyTypeRelator().Map, sql);
 
-            var propertyGroupFactory = new PropertyGroupFactory(id);
+            var propertyGroupFactory = new PropertyGroupFactory(id, createDate, updateDate);
             var propertyGroups = propertyGroupFactory.BuildEntity(dtos);
             return new PropertyGroupCollection(propertyGroups);
         }
 
-        protected PropertyTypeCollection GetPropertyTypeCollection(int id)
+        protected PropertyTypeCollection GetPropertyTypeCollection(int id, DateTime createDate, DateTime updateDate)
         {
             var sql = new Sql();
             sql.Select("*")
@@ -371,7 +373,9 @@ namespace Umbraco.Core.Persistence.Repositories
                                     HelpText = dto.HelpText,
                                     Mandatory = dto.Mandatory,
                                     SortOrder = dto.SortOrder,
-                                    ValidationRegExp = dto.ValidationRegExp
+                                    ValidationRegExp = dto.ValidationRegExp,
+                                    CreateDate = createDate,
+                                    UpdateDate = updateDate
                                 }).ToList();
 
             //Reset dirty properties

src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs

@@ -51,8 +51,8 @@ namespace Umbraco.Core.Persistence.Repositories
             var contentType = factory.BuildEntity(dto);
 
             contentType.AllowedContentTypes = GetAllowedContentTypeIds(id);
-            contentType.PropertyGroups = GetPropertyGroupCollection(id);
-            ((ContentType)contentType).PropertyTypes = GetPropertyTypeCollection(id);
+            contentType.PropertyGroups = GetPropertyGroupCollection(id, contentType.CreateDate, contentType.UpdateDate);
+            ((ContentType)contentType).PropertyTypes = GetPropertyTypeCollection(id, contentType.CreateDate, contentType.UpdateDate);
 
             var templates = Database.Fetch<DocumentTypeDto>("WHERE contentTypeNodeId = @Id", new { Id = id });
             if(templates.Any())

src/Umbraco.Core/Persistence/Repositories/EntityRepository.cs

@@ -262,7 +262,7 @@ namespace Umbraco.Core.Persistence.Repositories
             [Column("publishedVerison")]
             public Guid PublishedVersion { get; set; }
 
-            [Column("newestVerison")]
+            [Column("newestVersion")]
             public Guid NewestVersion { get; set; }
 
             [Column("alias")]

src/Umbraco.Core/Persistence/Repositories/FileRepository.cs

@@ -111,6 +111,20 @@ namespace Umbraco.Core.Persistence.Repositories
 
         #endregion
 
+        protected IEnumerable<string> FindAllFiles(string path)
+        {
+            var list = new List<string>();
+            list.AddRange(FileSystem.GetFiles(path, "*"));
+
+            var directories = FileSystem.GetDirectories(path);
+            foreach (var directory in directories)
+            {
+                list.AddRange(FindAllFiles(directory));
+            }
+
+            return list;
+        }
+
 		/// <summary>
 		/// Dispose any disposable properties
 		/// </summary>

src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentRepository.cs

@@ -1,4 +1,6 @@
-using Umbraco.Core.Models;
+using System.Collections.Generic;
+using Umbraco.Core.Models;
+using Umbraco.Core.Persistence.Querying;
 
 namespace Umbraco.Core.Persistence.Repositories
 {
@@ -11,5 +13,12 @@ namespace Umbraco.Core.Persistence.Repositories
         /// <param name="language">Culture code for the language to retrieve</param>
         /// <returns>An <see cref="IContent"/> item</returns>
         IContent GetByLanguage(int id, string language);
+
+        /// <summary>
+        /// Gets all published Content byh the specified query
+        /// </summary>
+        /// <param name="query">Query to execute against published versions</param>
+        /// <returns>An enumerable list of <see cref="IContent"/></returns>
+        IEnumerable<IContent> GetByPublishedVersion(IQuery<IContent> query);
     }
 }

src/Umbraco.Core/Persistence/Repositories/Interfaces/IMacroRepository.cs

@@ -1,13 +0,0 @@
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Persistence.Repositories
-{
-    /// <summary>
-    /// Defines the Macro Repository, which exposes CRUD operations for <see cref="IMacro"/>
-    /// </summary>
-    /// <remarks>Uses string Alias as the Id type</remarks>
-    internal interface IMacroRepository : IRepositoryQueryable<string, IMacro>
-    {
-         
-    }
-}

src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs

@@ -1,132 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using Umbraco.Core.IO;
-using Umbraco.Core.Models;
-using Umbraco.Core.Models.EntityBase;
-using Umbraco.Core.Persistence.Caching;
-using Umbraco.Core.Persistence.Querying;
-using Umbraco.Core.Persistence.UnitOfWork;
-using Umbraco.Core.Serialization;
-
-namespace Umbraco.Core.Persistence.Repositories
-{
-    /// <summary>
-    /// Represents the Macro Repository
-    /// </summary>
-    internal class MacroRepository : RepositoryBase<string, IMacro>, IMacroRepository
-    {
-        private IFileSystem _fileSystem;
-        private SerializationService _serializationService;
-
-		public MacroRepository(IUnitOfWork work)
-			: base(work)
-        {
-            EnsureDependencies();
-        }
-
-		public MacroRepository(IUnitOfWork work, IRepositoryCacheProvider cache)
-            : base(work, cache)
-        {
-            EnsureDependencies();
-        }
-
-        private void EnsureDependencies()
-        {            
-			_fileSystem = new PhysicalFileSystem("~/App_Data/Macros");
-            var jsonSerializer = new JsonNetSerializer();
-            _serializationService = new SerializationService(jsonSerializer);
-        }
-
-        #region Overrides of RepositoryBase<string,IMacro>
-
-        protected override IMacro PerformGet(string id)
-        {
-            var name = string.Concat(id, ".macro");
-            Stream file = _fileSystem.OpenFile(name);
-            var o = _serializationService.FromStream(file, typeof(Macro));
-            var macro = o as IMacro;
-
-            //on initial construction we don't want to have dirty properties tracked
-            // http://issues.umbraco.org/issue/U4-1946
-            if(macro != null)
-                ((Entity)macro).ResetDirtyProperties(false);
-
-            return macro;
-        }
-
-        protected override IEnumerable<IMacro> PerformGetAll(params string[] ids)
-        {
-            if (ids.Any())
-            {
-                foreach (var id in ids)
-                {
-                    yield return Get(id);
-                }
-            }
-            else
-            {
-                var files = _fileSystem.GetFiles("", "*.macro");
-                foreach (var file in files)
-                {
-                    yield return Get(file.Replace(".macro", ""));
-                }
-            }
-        }
-
-        protected override IEnumerable<IMacro> PerformGetByQuery(IQuery<IMacro> query)
-        {
-            throw new NotImplementedException();
-        }
-
-        protected override bool PerformExists(string id)
-        {
-            var name = string.Concat(id, ".macro");
-            return _fileSystem.FileExists(name);
-        }
-
-        protected override int PerformCount(IQuery<IMacro> query)
-        {
-            var files = _fileSystem.GetFiles("", "*.macro");
-            return files.Count();
-        }
-
-        #endregion
-
-        #region Overrides of IUnitOfWorkRepository
-
-        protected override void PersistNewItem(IMacro entity)
-        {
-            ((Macro)entity).AddingEntity();
-
-            var name = string.Concat(entity.Alias, ".macro");
-            var json = _serializationService.ToStream(entity);
-            _fileSystem.AddFile(name, json.ResultStream, true);
-
-            ((ICanBeDirty)entity).ResetDirtyProperties();
-        }
-
-        protected override void PersistUpdatedItem(IMacro entity)
-        {
-            ((Macro)entity).UpdatingEntity();
-
-            var name = string.Concat(entity.Alias, ".macro");
-            var json = _serializationService.ToStream(entity);
-            _fileSystem.AddFile(name, json.ResultStream, true);
-
-            ((ICanBeDirty)entity).ResetDirtyProperties();
-        }
-
-        protected override void PersistDeletedItem(IMacro entity)
-        {
-            var name = string.Concat(entity.Alias, ".macro");
-            if (_fileSystem.FileExists(name))
-            {
-                _fileSystem.DeleteFile(name);
-            }
-        }
-
-        #endregion
-    }
-}

src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs

@@ -51,7 +51,7 @@ namespace Umbraco.Core.Persistence.Repositories
             var factory = new MediaFactory(mediaType, NodeObjectTypeId, id);
             var media = factory.BuildEntity(dto);
 
-            media.Properties = GetPropertyCollection(id, dto.VersionId, mediaType);
+            media.Properties = GetPropertyCollection(id, dto.VersionId, mediaType, media.CreateDate, media.UpdateDate);
 
             //on initial construction we don't want to have dirty properties tracked
             // http://issues.umbraco.org/issue/U4-1946
@@ -120,6 +120,8 @@ namespace Umbraco.Core.Persistence.Repositories
                            {
                                "DELETE FROM umbracoUser2NodeNotify WHERE nodeId = @Id",
                                "DELETE FROM umbracoUser2NodePermission WHERE nodeId = @Id",
+                               "DELETE FROM umbracoRelation WHERE parentId = @Id",
+                               "DELETE FROM umbracoRelation WHERE childId = @Id",
                                "DELETE FROM cmsTagRelationship WHERE nodeId = @Id",
                                "DELETE FROM cmsDocument WHERE NodeId = @Id",
                                "DELETE FROM cmsPropertyData WHERE contentNodeId = @Id",
@@ -157,7 +159,7 @@ namespace Umbraco.Core.Persistence.Repositories
             var factory = new MediaFactory(mediaType, NodeObjectTypeId, dto.NodeId);
             var media = factory.BuildEntity(dto);
 
-            media.Properties = GetPropertyCollection(dto.NodeId, dto.VersionId, mediaType);
+            media.Properties = GetPropertyCollection(dto.NodeId, dto.VersionId, mediaType, media.CreateDate, media.UpdateDate);
 
             //on initial construction we don't want to have dirty properties tracked
             // http://issues.umbraco.org/issue/U4-1946
@@ -342,7 +344,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         #endregion
 
-        private PropertyCollection GetPropertyCollection(int id, Guid versionId, IMediaType contentType)
+        private PropertyCollection GetPropertyCollection(int id, Guid versionId, IMediaType contentType, DateTime createDate, DateTime updateDate)
         {
             var sql = new Sql();
             sql.Select("*")
@@ -353,7 +355,7 @@ namespace Umbraco.Core.Persistence.Repositories
                 .Where<PropertyDataDto>(x => x.VersionId == versionId);
 
             var propertyDataDtos = Database.Fetch<PropertyDataDto, PropertyTypeDto>(sql);
-            var propertyFactory = new PropertyFactory(contentType, versionId, id);
+            var propertyFactory = new PropertyFactory(contentType, versionId, id, createDate, updateDate);
             var properties = propertyFactory.BuildEntity(propertyDataDtos);
 
             var newProperties = properties.Where(x => x.HasIdentity == false);

src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs

@@ -42,8 +42,8 @@ namespace Umbraco.Core.Persistence.Repositories
             var contentType = factory.BuildEntity(dto);
             
             contentType.AllowedContentTypes = GetAllowedContentTypeIds(id);
-            contentType.PropertyGroups = GetPropertyGroupCollection(id);
-            ((MediaType)contentType).PropertyTypes = GetPropertyTypeCollection(id);
+            contentType.PropertyGroups = GetPropertyGroupCollection(id, contentType.CreateDate, contentType.UpdateDate);
+            ((MediaType)contentType).PropertyTypes = GetPropertyTypeCollection(id, contentType.CreateDate, contentType.UpdateDate);
 
             var list = Database.Fetch<ContentType2ContentTypeDto>("WHERE childContentTypeId = @Id", new{ Id = id});
             foreach (var contentTypeDto in list)

src/Umbraco.Core/Persistence/Repositories/ScriptRepository.cs

@@ -45,12 +45,11 @@ namespace Umbraco.Core.Persistence.Repositories
             var path = FileSystem.GetRelativePath(id);
             var created = FileSystem.GetCreated(path).UtcDateTime;
             var updated = FileSystem.GetLastModified(path).UtcDateTime;
-            var name = new FileInfo(path).Name;
 
             var script = new Script(path)
                              {
                                  Content = content,
-                                 Key = name.EncodeAsGuid(),
+                                 Key = path.EncodeAsGuid(),
                                  CreateDate = created,
                                  UpdateDate = updated
                              };
@@ -73,7 +72,7 @@ namespace Umbraco.Core.Persistence.Repositories
             }
             else
             {
-                var files = FileSystem.GetFiles("", "*");
+                var files = FindAllFiles("");
                 foreach (var file in files)
                 {
                     yield return Get(file);

src/Umbraco.Core/Persistence/Repositories/StylesheetRepository.cs

@@ -47,12 +47,11 @@ namespace Umbraco.Core.Persistence.Repositories
             var path = FileSystem.GetRelativePath(id);
             var created = FileSystem.GetCreated(path).UtcDateTime;
             var updated = FileSystem.GetLastModified(path).UtcDateTime;
-            var name = new FileInfo(path).Name;
 
             var stylesheet = new Stylesheet(path)
                                  {
                                      Content = content,
-                                     Key = name.EncodeAsGuid(),
+                                     Key = path.EncodeAsGuid(),
                                      CreateDate = created,
                                      UpdateDate = updated
                                  };
@@ -75,7 +74,7 @@ namespace Umbraco.Core.Persistence.Repositories
             }
             else
             {
-                var files = FileSystem.GetFiles("", "*");
+                var files = FindAllFiles("");
                 foreach (var file in files)
                 {
                     yield return Get(file);

src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs

@@ -191,6 +191,8 @@ namespace Umbraco.Core.Persistence.Repositories
 
             //Save to db
             var template = entity as Template;
+            template.AddingEntity();
+
             var factory = new TemplateFactory(NodeObjectTypeId);
             var dto = factory.BuildDto(template);
 
@@ -259,6 +261,7 @@ namespace Umbraco.Core.Persistence.Repositories
             var templateDto = Database.SingleOrDefault<TemplateDto>("WHERE nodeId = @Id", new { Id = entity.Id });
             //Save updated entity to db
             var template = entity as Template;
+            template.UpdateDate = DateTime.Now;
             var factory = new TemplateFactory(templateDto.PrimaryKey, NodeObjectTypeId);
             var dto = factory.BuildDto(template);
 

src/Umbraco.Core/Persistence/RepositoryFactory.cs

@@ -76,13 +76,6 @@ namespace Umbraco.Core.Persistence
                 InMemoryCacheProvider.Current);
         }
 
-		internal virtual IMacroRepository CreateMacroRepository(IUnitOfWork uow)
-        {
-            return new MacroRepository(
-                uow,
-                InMemoryCacheProvider.Current);
-        }
-
         public virtual IMediaRepository CreateMediaRepository(IDatabaseUnitOfWork uow)
         {
             return new MediaRepository(

src/Umbraco.Core/Persistence/UmbracoDatabase.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Data;
 using System.Data.Common;
+using StackExchange.Profiling;
 using Umbraco.Core.Logging;
 
 namespace Umbraco.Core.Persistence
@@ -40,6 +41,13 @@ namespace Umbraco.Core.Persistence
 		{
 		}
 
+        public override IDbConnection OnConnectionOpened(IDbConnection connection)
+        {
+            // wrap the connection with a profiling connection that tracks timings 
+            return new StackExchange.Profiling.Data.ProfiledDbConnection(connection as DbConnection, MiniProfiler.Current);
+        }
+
+
         public override void OnException(Exception x)
         {
             LogHelper.Info<UmbracoDatabase>(x.StackTrace);

src/Umbraco.Core/PluginManager.cs

@@ -487,15 +487,6 @@ namespace Umbraco.Core
             return ResolveTypes<IAction>();
         }
 
-        /// <summary>
-        /// Returns all available IMacroPropertyTypes in application
-        /// </summary>
-        /// <returns></returns>
-        internal IEnumerable<Type> ResolveMacroPropertyTypes()
-        {
-            return ResolveTypes<IMacroPropertyType>();
-        }
-
         /// <summary>
         /// Returns all mapper types that have a MapperFor attribute defined
         /// </summary>

src/Umbraco.Core/Profiling/IProfiler.cs

@@ -0,0 +1,43 @@
+using System;
+
+namespace Umbraco.Core.Profiling
+{
+    /// <summary>
+    /// Defines an object for use in the application to profile operations
+    /// </summary>
+    internal interface IProfiler
+    {
+        /// <summary>
+        /// Render the UI to display the profiler 
+        /// </summary>
+        /// <returns></returns>
+        /// <remarks>
+        /// Generally used for HTML displays
+        /// </remarks>
+        string Render();
+
+        /// <summary>
+        /// Profile an operation
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// Use the 'using(' syntax
+        /// </remarks>
+        IDisposable Step(string name);
+   
+        /// <summary>
+        /// Start the profiler
+        /// </summary>
+        void Start();
+
+        /// <summary>
+        /// Start the profiler
+        /// </summary>
+        /// <remarks>
+        /// set discardResults to false when you want to abandon all profiling, this is useful for 
+        /// when someone is not authenticated or you want to clear the results based on some other mechanism.
+        /// </remarks>
+        void Stop(bool discardResults = false);
+    }
+}

src/Umbraco.Core/Profiling/LogProfiler.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Umbraco.Core.Logging;
+
+namespace Umbraco.Core.Profiling
+{
+    /// <summary>
+    /// A profiler that outputs its results to the LogHelper
+    /// </summary>
+    internal class LogProfiler : IProfiler
+    {
+        public string Render()
+        {
+            return string.Empty;
+        }
+
+        public IDisposable Step(string name)
+        {
+            LogHelper.Debug(typeof(LogProfiler), "Starting - " + name);
+            return DisposableTimer.Start(l => LogHelper.Info(typeof(LogProfiler), () => name + " (took " + l + "ms)"));
+        }
+
+        public void Start()
+        {
+            //the log will alwasy be started   
+        }
+
+        public void Stop(bool discardResults = false)
+        {
+            //we don't need to do anything here
+        }
+    }
+}

src/Umbraco.Core/Profiling/ProfilerExtensions.cs

@@ -0,0 +1,35 @@
+using System;
+
+namespace Umbraco.Core.Profiling
+{
+    internal static class ProfilerExtensions
+    {
+        /// <summary>
+        /// Writes out a step prefixed with the type
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="profiler"></param>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        internal static IDisposable Step<T>(this IProfiler profiler, string name)
+        {
+            if (profiler == null) throw new ArgumentNullException("profiler");
+            return profiler.Step(typeof (T), name);
+        }
+
+        /// <summary>
+        /// Writes out a step prefixed with the type
+        /// </summary>
+        /// <param name="profiler"></param>
+        /// <param name="objectType"></param>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        internal static IDisposable Step(this IProfiler profiler, Type objectType, string name)
+        {
+            if (profiler == null) throw new ArgumentNullException("profiler");
+            if (objectType == null) throw new ArgumentNullException("objectType");
+            if (name == null) throw new ArgumentNullException("name");
+            return profiler.Step(string.Format("[{0}] {1}", objectType.Name, name));
+        }
+    }
+}

src/Umbraco.Core/Profiling/ProfilerResolver.cs

@@ -0,0 +1,39 @@
+using Umbraco.Core.ObjectResolution;
+
+namespace Umbraco.Core.Profiling
+{
+    /// <summary>
+    /// A resolver exposing the current profiler
+    /// </summary>
+    internal class ProfilerResolver : SingleObjectResolverBase<ProfilerResolver, IProfiler>
+    {
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="profiler"></param>
+        public ProfilerResolver(IProfiler profiler)
+            : base(profiler)
+        {
+
+        }
+
+        /// <summary>
+        /// Method allowing to change the profiler during startup
+        /// </summary>
+        /// <param name="profiler"></param>
+        internal void SetProfiler(IProfiler profiler)
+        {
+            Value = profiler;
+        }
+
+        /// <summary>
+        /// Gets the current profiler
+        /// </summary>
+        public IProfiler Profiler
+        {
+            get { return Value; }
+        }
+
+        
+    }
+}

src/Umbraco.Core/Profiling/WebProfiler.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Web;
+using StackExchange.Profiling;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Logging;
+
+namespace Umbraco.Core.Profiling
+{
+    /// <summary>
+    /// A profiler used for web based activity based on the MiniProfiler framework
+    /// </summary>
+    internal class WebProfiler : IProfiler
+    {
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <remarks>
+        /// Binds to application events to enable the MiniProfiler
+        /// </remarks>
+        internal WebProfiler()
+        {
+            UmbracoApplicationBase.ApplicationInit += UmbracoApplicationApplicationInit;
+        }
+
+        /// <summary>
+        /// Handle the Init event o fthe UmbracoApplication which allows us to subscribe to the HttpApplication events
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void UmbracoApplicationApplicationInit(object sender, EventArgs e)
+        {
+            var app = sender as HttpApplication;
+            if (app == null) return;
+
+            if (SystemUtilities.GetCurrentTrustLevel() < AspNetHostingPermissionLevel.High)
+            {
+                //If we don't have a high enough trust level we cannot bind to the events
+                LogHelper.Info<WebProfiler>("Cannot start the WebProfiler since the application is running in Medium trust");
+            }
+            else
+            {
+                app.BeginRequest += UmbracoApplicationBeginRequest;
+                app.EndRequest += UmbracoApplicationEndRequest;
+            }
+        }
+
+        /// <summary>
+        /// Handle the begin request event
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void UmbracoApplicationEndRequest(object sender, EventArgs e)
+        {
+            if (GlobalSettings.DebugMode == false) return;
+            var request = TryGetRequest(sender);
+            if (request.Success == false) return;
+            if (request.Result.Url.IsClientSideRequest()) return;
+            if (string.IsNullOrEmpty(request.Result["umbDebug"]) == false)
+            {
+                //stop the profiler
+                Stop();
+            }
+        }
+
+        /// <summary>
+        /// Handle the end request event
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void UmbracoApplicationBeginRequest(object sender, EventArgs e)
+        {
+            if (GlobalSettings.DebugMode == false) return;
+            var request = TryGetRequest(sender);
+            if (request.Success == false) return;
+            if (request.Result.Url.IsClientSideRequest()) return;
+            if (string.IsNullOrEmpty(request.Result["umbDebug"]) == false)
+            {
+                //start the profiler
+                Start();
+            }
+        }
+
+        /// <summary>
+        /// Render the UI to display the profiler 
+        /// </summary>
+        /// <returns></returns>
+        /// <remarks>
+        /// Generally used for HTML displays
+        /// </remarks>
+        public string Render()
+        {
+            return MiniProfiler.RenderIncludes().ToString();
+        }
+
+        /// <summary>
+        /// Profile a step
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// Use the 'using(' syntax
+        /// </remarks>
+        public IDisposable Step(string name)
+        {
+            if (GlobalSettings.DebugMode == false) return null;
+
+            return MiniProfiler.Current.Step(name);
+        }
+
+        /// <summary>
+        /// Start the profiler
+        /// </summary>
+        public void Start()
+        {
+            if (GlobalSettings.DebugMode == false) return;
+            //will not run in medium trust
+            if (SystemUtilities.GetCurrentTrustLevel() < AspNetHostingPermissionLevel.High) return;
+
+            MiniProfiler.Start();
+        }
+
+        /// <summary>
+        /// Start the profiler
+        /// </summary>
+        /// <remarks>
+        /// set discardResults to false when you want to abandon all profiling, this is useful for 
+        /// when someone is not authenticated or you want to clear the results based on some other mechanism.
+        /// </remarks>
+        public void Stop(bool discardResults = false)
+        {
+            if (GlobalSettings.DebugMode == false) return;
+            //will not run in medium trust
+            if (SystemUtilities.GetCurrentTrustLevel() < AspNetHostingPermissionLevel.High) return;
+
+            MiniProfiler.Stop(discardResults);
+        }
+
+        /// <summary>
+        /// Gets the request object from the app instance if it is available
+        /// </summary>
+        /// <param name="sender">The application object</param>
+        /// <returns></returns>
+        private Attempt<HttpRequestBase> TryGetRequest(object sender)
+        {
+            var app = sender as HttpApplication;
+            if (app == null) return Attempt<HttpRequestBase>.False;
+
+            try
+            {
+                var req = app.Request;
+                return new Attempt<HttpRequestBase>(true, new HttpRequestWrapper(req));
+            }
+            catch (HttpException ex)
+            {
+                return new Attempt<HttpRequestBase>(ex);
+            }
+        }
+
+    }
+}

src/Umbraco.Core/Properties/AssemblyInfo.cs

@@ -29,11 +29,11 @@ using System.Security.Permissions;
 [assembly: InternalsVisibleTo("businesslogic")]
 [assembly: InternalsVisibleTo("cms")]
 [assembly: InternalsVisibleTo("umbraco.editorControls")]
+[assembly: InternalsVisibleTo("umbraco.webservices")]
 [assembly: InternalsVisibleTo("umbraco.datalayer")]
 [assembly: InternalsVisibleTo("umbraco.MacroEngines")]
 
 [assembly: InternalsVisibleTo("umbraco.editorControls")]
-[assembly: InternalsVisibleTo("umbraco.webservices")]
 [assembly: InternalsVisibleTo("Umbraco.Tests")]
 [assembly: InternalsVisibleTo("Umbraco.Core")]
 [assembly: InternalsVisibleTo("Umbraco.Web")]
@@ -41,4 +41,6 @@ using System.Security.Permissions;
 [assembly: InternalsVisibleTo("UmbracoExamine")]
 [assembly: InternalsVisibleTo("Umbraco.Courier.Persistence")]
 
-[assembly: InternalsVisibleTo("Concorde.Sync")]
+[assembly: InternalsVisibleTo("Concorde.Sync")]
+[assembly: InternalsVisibleTo("Umbraco.Belle")]
+[assembly: InternalsVisibleTo("Umbraco.VisualStudio")]

src/Umbraco.Core/PropertyEditors/Attributes/PropertyEditorAttribute.cs

@@ -1,48 +0,0 @@
-using System;
-
-namespace Umbraco.Core.PropertyEditors.Attributes
-{
-    /// <summary>
-    /// Defines a PropertyEditor
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
-    internal sealed class PropertyEditorAttribute : Attribute
-    {
-        public PropertyEditorAttribute(string id, string alias, string name)
-        {
-            Mandate.ParameterNotNullOrEmpty(id, "id");
-            Mandate.ParameterNotNullOrEmpty(alias, "alias");
-            Mandate.ParameterNotNullOrEmpty(name, "name");
-            
-            Id = Guid.Parse(id);
-            Alias = alias;
-            Name = name;
-
-            IsContentPropertyEditor = true;
-        }
-
-        public Guid Id { get; private set; }
-
-        /// <summary>
-        /// Gets or sets the name.
-        /// </summary>
-        /// <value>The name.</value>
-        public string Name { get; set; }
-
-        /// <summary>
-        /// Gets or sets the alias.
-        /// </summary>
-        /// <value>The alias.</value>
-        public string Alias { get; set; }
-
-        /// <summary>
-        /// Flag determining if this property editor is used to edit content
-        /// </summary>
-        public bool IsContentPropertyEditor { get; set; }
-
-        /// <summary>
-        /// Flag determining if this property editor is used to edit parameters
-        /// </summary>
-        public bool IsParameterEditor { get; set; }
-    }
-}