Adds new installer image

Adds changes to the CMSNode and doc type related class which improves the internal usage of the new model based on IUmbracoEntity.

.gitignore

@@ -78,6 +78,12 @@ src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/loader.js
 src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/main.js
 src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/app.js
 
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.panel.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.palettes.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.loader.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.front.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.config.js
+
 src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/
 src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/**/*.js
 src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/**/*.css

build/Build.bat

@@ -1,6 +1,10 @@
 @ECHO OFF
-SET release=7.1.2
-SET comment=
+IF NOT EXIST UmbracoVersion.txt (
+	ECHO UmbracoVersion.txt missing!
+	GOTO :showerror
+) 
+SET /p release=<UmbracoVersion.txt
+SET comment=alpha
 SET version=%release%
 
 IF [%comment%] EQU [] (SET version=%release%) ELSE (SET version=%release%-%comment%)
@@ -15,6 +19,11 @@ SET nuGetFolder=%CD%\..\src\packages\
 ECHO Removing the belle build folder to make sure everything is clean as a whistle
 RD ..\src\Umbraco.Web.UI.Client\build /Q /S
 
+ECHO Removing existing built files to make sure everything is clean as a whistle
+DEL /F /Q UmbracoCms.*.zip
+DEL /F /Q UmbracoCms.*.nupkg
+DEL /F /Q webpihash.txt
+
 ECHO Performing MSBuild and producing Umbraco binaries zip files
 %windir%\Microsoft.NET\Framework\v4.0.30319\msbuild.exe "Build.proj" /p:BUILD_RELEASE=%release% /p:BUILD_COMMENT=%comment%
 

build/Build.proj

@@ -325,7 +325,7 @@
       Regex="CurrentComment { get { return "([a-zA-Z]+)?""
       ReplacementText="CurrentComment { get { return "$(BUILD_COMMENT)""/>
 	
-	<XmlPoke XmlInputPath=".\NuSpecs\build\UmbracoCms.targets"
+	<XmlPoke XmlInputPath=".\NuSpecs\build\UmbracoCms.props"
              Namespaces="&lt;Namespace Prefix='x' Uri='http://schemas.microsoft.com/developer/msbuild/2003' /&gt;"
 			 Query="//x:UmbracoVersion"
 			 Value="$(NewVersion)" />

build/BuildBelle.bat

@@ -1,4 +1,5 @@
 @ECHO OFF
+SET release=%1
 ECHO Installing Npm NuGet Package
 
 SET nuGetFolder=%CD%\..\src\packages\
@@ -26,7 +27,7 @@ ECHO Do npm install and the grunt build of Belle
 call npm install
 call npm install -g grunt-cli
 call npm install -g bower
-call grunt build --buildversion=7.1.2
+call grunt build --buildversion=%release%
 
 ECHO Reset path to what it was before
 path=%oldPath%

build/NuSpecs/UmbracoCms.Core.nuspec

@@ -67,5 +67,6 @@
         <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" />
+		<file src="tools\install.core.ps1" target="tools\install.ps1" />
     </files>
 </package>

build/NuSpecs/build/UmbracoCms.props

@@ -1,12 +1,11 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <CopyAllFilesToSingleFolderForPackageDependsOn>
       AddUmbracoFilesToOutput;
       $(CopyAllFilesToSingleFolderForPackageDependsOn);
     </CopyAllFilesToSingleFolderForPackageDependsOn>
-	
-	<CopyAllFilesToSingleFolderForMsdeployDependsOn>
+    <CopyAllFilesToSingleFolderForMsdeployDependsOn>
       AddUmbracoFilesToOutput;
       $(CopyAllFilesToSingleFolderForPackageDependsOn);
     </CopyAllFilesToSingleFolderForMsdeployDependsOn>

build/NuSpecs/build/UmbracoCms.targets

@@ -1,11 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <UmbracoVersion>7.1.2</UmbracoVersion>
-  </PropertyGroup>
   <Target Name="CopyUmbracoFilesToWebRoot" BeforeTargets="AfterBuild">
     <PropertyGroup>
-      <UmbracoFilesFolder>..\packages\UmbracoCms.$(UmbracoVersion)\UmbracoFiles\</UmbracoFilesFolder>
+      <UmbracoFilesFolder>$(MSBuildThisFileDirectory)..\UmbracoFiles\</UmbracoFilesFolder>
     </PropertyGroup>
     <ItemGroup>
       <UmbracoFiles Include="$(UmbracoFilesFolder)**\*" />
@@ -33,6 +30,9 @@
       <CustomFilesToInclude Include=".\Config\Splashes\**\*">
         <Dir>Config\Splashes</Dir>
       </CustomFilesToInclude>
+      <CustomFilesToInclude Include=".\data\**\*">
+        <Dir>data</Dir>
+      </CustomFilesToInclude>
       <CustomFilesToInclude Include=".\umbraco\**\*">
         <Dir>umbraco</Dir>
       </CustomFilesToInclude>

build/NuSpecs/tools/install.core.ps1

@@ -0,0 +1,24 @@
+param($rootPath, $toolsPath, $package, $project)
+
+if ($project) {
+	$dateTime = Get-Date -Format yyyyMMdd-HHmmss
+	$backupPath = Join-Path (Split-Path $project.FullName -Parent) "\App_Data\NuGetBackup\$dateTime"
+	$copyLogsPath = Join-Path $backupPath "CopyLogs"
+	$projectDestinationPath = Split-Path $project.FullName -Parent
+	
+	# Create backup folder and logs folder if it doesn't exist yet
+	New-Item -ItemType Directory -Force -Path $backupPath
+	New-Item -ItemType Directory -Force -Path $copyLogsPath
+	
+	# After backing up, remove all dlls from bin folder in case dll files are included in the VS project
+	# See: http://issues.umbraco.org/issue/U4-4930
+	$umbracoBinFolder = Join-Path $projectDestinationPath "bin"
+	if(Test-Path $umbracoBinFolder) {
+		$umbracoBinBackupPath = Join-Path $backupPath "bin"
+		
+		New-Item -ItemType Directory -Force -Path $umbracoBinBackupPath
+		
+		robocopy $umbracoBinFolder $umbracoBinBackupPath /e /LOG:$copyLogsPath\UmbracoBinBackup.log
+		Remove-Item $umbracoBinFolder\*.dll -Force -Confirm:$false
+	}
+}

build/UmbracoVersion.txt

@@ -0,0 +1 @@
+7.2.0

src/SQLCE4Umbraco/SqlCE4Umbraco.csproj

@@ -77,6 +77,7 @@
     <Compile Include="SqlCEUtility.cs" />
   </ItemGroup>
   <ItemGroup>
+    <None Include="app.config" />
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>

src/SQLCE4Umbraco/app.config

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.0.0" newVersion="4.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Web.WebPages" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-2.0.0.0" newVersion="2.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>

src/Umbraco.Core/Configuration/UmbracoVersion.cs

@@ -5,7 +5,7 @@ namespace Umbraco.Core.Configuration
 {
     public class UmbracoVersion
     {
-        private static readonly Version Version = new Version("7.1.2");
+        private static readonly Version Version = new Version("7.2.0");
 
         /// <summary>
         /// Gets the current version of Umbraco.
@@ -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 ""; } }
+        public static string CurrentComment { get { return "alpha"; } }
 
         // 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/Constants-Applications.cs

@@ -70,6 +70,11 @@
 
             //TODO: Fill in the rest!
 
+            /// <summary>
+            /// alias for the media tree.
+            /// </summary>
+            public const string Templates = "template";
+
         }
 	}
 

src/Umbraco.Core/Constants-PropertyEditors.cs

@@ -130,6 +130,12 @@ namespace Umbraco.Core
             /// </summary>
             public const string FolderBrowserAlias = "Umbraco.FolderBrowser";
 
+            /// <summary>
+            /// Alias for the grid datatype.
+            /// </summary>
+            public const string GridAlias = "Umbraco.Grid";
+
+
             /// <summary>
             /// Guid for the Image Cropper datatype.
             /// </summary>

src/Umbraco.Core/CoreBootManager.cs

@@ -329,9 +329,8 @@ namespace Umbraco.Core
 		    UrlSegmentProviderResolver.Current = new UrlSegmentProviderResolver(
 		        typeof (DefaultUrlSegmentProvider));
 
-            // keep it internal for now
+            // by default, no factory is activated
 		    PublishedContentModelFactoryResolver.Current = new PublishedContentModelFactoryResolver();
-		    //    new PublishedContentModelFactoryImpl());
 		}
 	}
 }

src/Umbraco.Core/Dynamics/DynamicInstanceHelper.cs

@@ -117,13 +117,12 @@ namespace Umbraco.Core.Dynamics
 						}
 						catch (Exception ex)
 						{
-							var sb = new StringBuilder("An error occurred finding an executing an extension method for type ");
-							sb.Append(typeof (T));
-							sb.Append("Types searched for extension methods were ");
-							foreach(var t in findExtensionMethodsOnTypes)
-							{
-								sb.Append(t + ",");
-							}
+                            var sb = new StringBuilder();
+                            sb.AppendFormat("An error occurred finding and executing extension method \"{0}\" ", binder.Name);
+                            sb.AppendFormat("for type \"{0}\". ", typeof (T));
+                            sb.Append("Types searched for extension methods were ");
+                            sb.Append(string.Join(", ", findExtensionMethodsOnTypes));
+                            sb.Append(".");
 							LogHelper.Error<DynamicInstanceHelper>(sb.ToString(), ex);
                             var mresult = new TryInvokeMemberResult(null, TryInvokeMemberSuccessReason.FoundExtensionMethod);
                             return Attempt<TryInvokeMemberResult>.Fail(mresult, ex);
@@ -171,7 +170,7 @@ namespace Umbraco.Core.Dynamics
 			}
 			else
 			{
-				throw new MissingMethodException();
+				throw new MissingMethodException(typeof(T).FullName, name);
 			}			
 			return result;
 		}

src/Umbraco.Core/Manifest/ManifestWatcher.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Web;
+using Umbraco.Core.Logging;
+
+namespace Umbraco.Core.Manifest
+{
+    internal class ManifestWatcher : DisposableObject
+    {
+        private readonly List<FileSystemWatcher> _fws = new List<FileSystemWatcher>();
+
+        public void Start(params string[] packageFolders)
+        {
+            foreach (var packageFolder in packageFolders)
+            {
+                if (Directory.Exists(packageFolder) && File.Exists(Path.Combine(packageFolder, "package.manifest")))
+                {
+                    //NOTE: for some reason *.manifest doesn't work!
+                    var fsw = new FileSystemWatcher(packageFolder, "*package.*")
+                    {
+                        IncludeSubdirectories = false,
+                        NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite 
+                    };
+                    _fws.Add(fsw);
+                    fsw.Changed += FswChanged;
+                    fsw.EnableRaisingEvents = true;
+                }
+            }
+        }
+
+        void FswChanged(object sender, FileSystemEventArgs e)
+        {
+            if (e.Name.InvariantContains("package.manifest"))
+            {
+                LogHelper.Info<ManifestWatcher>("manifest has changed, app pool is restarting (" + e.FullPath + ")");
+                HttpRuntime.UnloadAppDomain();
+                Dispose();    
+            }
+        }
+
+        protected override void DisposeResources()
+        {
+            foreach (var fw in _fws)
+            {
+                fw.Dispose();
+            }
+        }
+    }
+}

src/Umbraco.Core/Media/ImageHelper.cs

@@ -44,14 +44,18 @@ namespace Umbraco.Core.Media
 
             var result = new List<ResizedImage>();
 
-            var allSizes = new List<int> {100, 500};
+            var allSizesDictionary = new Dictionary<int,string> {{100,"thumb"}, {500,"big-thumb"}};
+            var allSizes = allSizesDictionary.Select(kv => kv.Key).ToList();
             allSizes.AddRange(additionalThumbSizes.Where(x => x > 0).Distinct());
+            var sizesDictionary = allSizes.ToDictionary(s => s, s => allSizesDictionary.ContainsKey(s) ? allSizesDictionary[s]: "");
 
-            foreach (var s in allSizes)
+            foreach (var s in sizesDictionary)
             {
-                if (originalImage.Width >= s && originalImage.Height >= s)
+                var size = s.Key;
+                var name = s.Value;
+                if (originalImage.Width >= size && originalImage.Height >= size)
                 {
-                    result.Add(Resize(fs, fileName, extension, s, "thumb", originalImage));
+                    result.Add(Resize(fs, fileName, extension, size, name, originalImage));
                 }
             }
 

src/Umbraco.Core/Models/ContentExtensions.cs

@@ -9,6 +9,8 @@ using System.Linq;
 using System.Web;
 using System.Xml;
 using System.Xml.Linq;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.IO;
@@ -539,7 +541,7 @@ namespace Umbraco.Core.Models
 
             return ApplicationContext.Current.Services.ContentService.HasPublishedVersion(content.Id);
         }
-        
+
         #region Tag methods
 
         ///// <summary>
@@ -567,6 +569,21 @@ namespace Umbraco.Core.Models
         /// <param name="tagGroup">The group/category to assign the tags, the default value is "default"</param>
         /// <returns></returns>
         public static void SetTags(this IContentBase content, string propertyTypeAlias, IEnumerable<string> tags, bool replaceTags, string tagGroup = "default")
+        {
+            content.SetTags(TagCacheStorageType.Csv, propertyTypeAlias, tags, replaceTags, tagGroup);
+        }
+
+        /// <summary>
+        /// Sets tags for the property - will add tags to the tags table and set the property value to be the comma delimited value of the tags.
+        /// </summary>
+        /// <param name="content">The content item to assign the tags to</param>
+        /// <param name="storageType">The tag storage type in cache (default is csv)</param>
+        /// <param name="propertyTypeAlias">The property alias to assign the tags to</param>
+        /// <param name="tags">The tags to assign</param>
+        /// <param name="replaceTags">True to replace the tags on the current property with the tags specified or false to merge them with the currently assigned ones</param>
+        /// <param name="tagGroup">The group/category to assign the tags, the default value is "default"</param>
+        /// <returns></returns>
+        public static void SetTags(this IContentBase content, TagCacheStorageType storageType, string propertyTypeAlias, IEnumerable<string> tags, bool replaceTags, string tagGroup = "default")
         {
             var property = content.Properties[propertyTypeAlias];
             if (property == null)
@@ -583,15 +600,39 @@ namespace Umbraco.Core.Models
             //ensure the property value is set to the same thing
             if (replaceTags)
             {
-                property.Value = string.Join(",", trimmedTags);
+                switch (storageType)
+                {
+                    case TagCacheStorageType.Csv:
+                        property.Value = string.Join(",", trimmedTags);
+                        break;
+                    case TagCacheStorageType.Json:
+                        //json array
+                        property.Value = JsonConvert.SerializeObject(trimmedTags);
+                        break;
+                }
+
             }
             else
             {
-                var currTags = property.Value.ToString().Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries)
+                switch (storageType)
+                {
+                    case TagCacheStorageType.Csv:
+                        var currTags = property.Value.ToString().Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
                                        .Select(x => x.Trim());
-                property.Value = string.Join(",", trimmedTags.Union(currTags));
+                        property.Value = string.Join(",", trimmedTags.Union(currTags));
+                        break;
+                    case TagCacheStorageType.Json:
+                        var currJson = JsonConvert.DeserializeObject<JArray>(property.Value.ToString());
+                        //need to append the new ones
+                        foreach (var tag in trimmedTags)
+                        {
+                            currJson.Add(tag);
+                        }
+                        //json array
+                        property.Value = JsonConvert.SerializeObject(currJson);
+                        break;
+                }
             }
-            
         }
 
         /// <summary>
@@ -664,7 +705,7 @@ namespace Umbraco.Core.Models
         {
             return ApplicationContext.Current.Services.PackagingService.Export(media, true, raiseEvents: false);
         }
-       
+
         /// <summary>
         /// Creates the xml representation for the <see cref="IContent"/> object
         /// </summary>
@@ -687,10 +728,10 @@ namespace Umbraco.Core.Models
         {
             return ((PackagingService)(ApplicationContext.Current.Services.PackagingService)).Export(member);
         }
-        
+
         #endregion
     }
-        
+
 
 
 }

src/Umbraco.Core/Models/ContentType.cs

@@ -133,29 +133,6 @@ namespace Umbraco.Core.Models
                 Key = Guid.NewGuid();
         }
 
-        /// <summary>
-        /// Method to call when Entity is being updated
-        /// </summary>
-        /// <remarks>Modified Date is set and a new Version guid is set</remarks>
-        internal override void UpdatingEntity()
-        {
-            base.UpdatingEntity();
-        }
-
-        public override object DeepClone()
-        {
-            var clone = (ContentType)base.DeepClone();
-            var propertyGroups = PropertyGroups.Select(x => (PropertyGroup)x.DeepClone()).ToList();
-            clone.PropertyGroups = new PropertyGroupCollection(propertyGroups);
-            //set the property types that are not part of a group
-            clone.PropertyTypes = PropertyTypeCollection
-                .Where(x => x.PropertyGroupId == null)
-                .Select(x => (PropertyType)x.DeepClone()).ToList();
-
-            clone.ResetDirtyProperties(false);
-
-            return clone;
-        }
 
         /// <summary>
         /// Creates a deep clone of the current entity with its identity/alias and it's property identities reset

src/Umbraco.Core/Models/ContentTypeBase.cs

@@ -331,11 +331,6 @@ namespace Umbraco.Core.Models
             get { return _additionalData; }
         }
 
-        /// <summary>
-        /// Some entities may expose additional data that other's might not, this custom data will be available in this collection
-        /// </summary>
-        public IDictionary<string, object> AdditionalData { get; private set; }
-
         /// <summary>
         /// Gets or sets a list of integer Ids for allowed ContentTypes
         /// </summary>
@@ -356,7 +351,9 @@ namespace Umbraco.Core.Models
         /// <summary>
         /// List of PropertyGroups available on this ContentType
         /// </summary>
-        /// <remarks>A PropertyGroup corresponds to a Tab in the UI</remarks>
+        /// <remarks>
+        /// A PropertyGroup corresponds to a Tab in the UI
+        /// </remarks>
         [DataMember]
         public virtual PropertyGroupCollection PropertyGroups
         {
@@ -372,7 +369,13 @@ namespace Umbraco.Core.Models
         /// List of PropertyTypes available on this ContentType.
         /// This list aggregates PropertyTypes across the PropertyGroups.
         /// </summary>
+        /// <remarks>
+        /// Marked as DoNotClone because the result of this property is not the natural result of the data, it is 
+        /// a union of data so when auto-cloning if the setter is used it will be setting the unnatural result of the 
+        /// data. We manually clone this instead. 
+        /// </remarks>
         [IgnoreDataMember]
+        [DoNotClone]
         public virtual IEnumerable<PropertyType> PropertyTypes
         {
             get
@@ -388,6 +391,14 @@ namespace Umbraco.Core.Models
         }
 
         /// <summary>
+        /// Returns the property type collection containing types that are non-groups - used for tests
+        /// </summary>
+        internal IEnumerable<PropertyType> NonGroupedPropertyTypes
+        {
+            get { return _propertyTypes; }
+        }
+
+            /// <summary>
         /// A boolean flag indicating if a property type has been removed from this instance.
         /// </summary>
         /// <remarks>
@@ -584,5 +595,19 @@ namespace Umbraco.Core.Models
                 propertyType.ResetDirtyProperties();
             }
         }
+
+        public override object DeepClone()
+        {
+            var clone = (ContentTypeBase)base.DeepClone();
+
+            //need to manually wire up the event handlers for the property type collections - we've ensured
+            // its ignored from the auto-clone process because its return values are unions, not raw and 
+            // we end up with duplicates, see: http://issues.umbraco.org/issue/U4-4842
+
+            clone._propertyTypes = (PropertyTypeCollection)_propertyTypes.DeepClone();
+            clone._propertyTypes.CollectionChanged += clone.PropertyTypesChanged;
+
+            return clone;
+        }
     }
 }

src/Umbraco.Core/Models/ContentTypeCompositionBase.cs

@@ -93,8 +93,17 @@ namespace Umbraco.Core.Models
         {
             if (ContentTypeCompositionExists(alias))
             {
-                var contentTypeComposition = ContentTypeComposition.First(x => x.Alias == alias);
+                var contentTypeComposition = ContentTypeComposition.FirstOrDefault(x => x.Alias == alias);
+                if (contentTypeComposition == null)//You can't remove a composition from another composition
+                    return false;
+
                 RemovedContentTypeKeyTracker.Add(contentTypeComposition.Id);
+                
+                //If the ContentType we are removing has Compositions of its own these needs to be removed as well
+                var compositionIdsToRemove = contentTypeComposition.CompositionIds().ToList();
+                if(compositionIdsToRemove.Any())
+                    RemovedContentTypeKeyTracker.AddRange(compositionIdsToRemove);
+
                 OnPropertyChanged(ContentTypeCompositionSelector);
                 return _contentTypeComposition.Remove(contentTypeComposition);
             }

src/Umbraco.Core/Models/DeepCloneHelper.cs

@@ -2,9 +2,29 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 
 namespace Umbraco.Core.Models
 {
+    /// <summary>
+    /// Used to attribute properties that have a setter and are a reference type
+    /// that should be ignored for cloning when using the DeepCloneHelper
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// This attribute must be used:
+    /// * when the property is backed by a field but the result of the property is the un-natural data stored in the field
+    ///  
+    /// This attribute should not be used:
+    /// * when the property is virtual
+    /// * when the setter performs additional required logic other than just setting the underlying field
+    /// 
+    /// </remarks>
+    internal class DoNotCloneAttribute : Attribute
+    {
+        
+    }
+
     public static class DeepCloneHelper
     {
         /// <summary>
@@ -25,8 +45,10 @@ namespace Umbraco.Core.Models
 
             var refProperties = inputType.GetProperties()
                 .Where(x =>
+                    //is not attributed with the ignore clone attribute
+                    x.GetCustomAttribute<DoNotCloneAttribute>() == null
                     //reference type but not string
-                    x.PropertyType.IsValueType == false && x.PropertyType != typeof (string)
+                    && x.PropertyType.IsValueType == false && x.PropertyType != typeof (string)
                         //settable
                     && x.CanWrite
                         //non-indexed

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

@@ -240,52 +240,6 @@ namespace Umbraco.Core.Models.EntityBase
             DeepCloneHelper.DeepCloneRefProperties(this, clone);
             clone.ResetDirtyProperties(false);
             return clone;
-
-            //Using data contract serializer - has issues
-
-            //var s = Serialize(this);
-            //var d = Deserialize(s, this.GetType());
-            //return d;
-
-            //Using binary serializer - has issues
-
-            //using (var memoryStream = new MemoryStream(10))
-            //{
-            //IFormatter formatter = new BinaryFormatter();
-            //formatter.Serialize(memoryStream, this);
-            //memoryStream.Seek(0, SeekOrigin.Begin);
-            //return formatter.Deserialize(memoryStream);
-            //}
         }
-
-        // serialize/deserialize with data contracts: 
-
-        //public static string Serialize(object obj)
-        //{
-        //    using (var memoryStream = new MemoryStream())
-        //    using (var reader = new StreamReader(memoryStream))
-        //    {
-        //        var serializer = new DataContractSerializer(obj.GetType());
-        //        serializer.WriteObject(memoryStream, obj);
-        //        memoryStream.Position = 0;
-        //        return reader.ReadToEnd();
-        //    }
-        //}
-
-        //public static object Deserialize(string xml, Type toType)
-        //{
-        //    using (Stream stream = new MemoryStream())
-        //    {
-        //        using (var writer = new StreamWriter(stream, Encoding.UTF8))
-        //        {
-        //            writer.Write(xml);
-        //            //byte[] data = Encoding.UTF8.GetBytes(xml);
-        //            //stream.Write(data, 0, data.Length);
-        //            stream.Position = 0;
-        //            var deserializer = new DataContractSerializer(toType);
-        //            return deserializer.ReadObject(stream);
-        //        }
-        //    }
-        //}
     }
 }

src/Umbraco.Core/Models/IMacroProperty.cs

@@ -6,7 +6,7 @@ namespace Umbraco.Core.Models
     /// <summary>
     /// Defines a Property for a Macro
     /// </summary>
-    public interface IMacroProperty : IValueObject
+    public interface IMacroProperty : IValueObject, IDeepCloneable, IRememberBeingDirty
     {
         [DataMember]
         int Id { get; set; }

src/Umbraco.Core/Models/Macro.cs

@@ -138,12 +138,11 @@ namespace Umbraco.Core.Models
 
                 var alias = prop.Alias;
 
-                //remove from the removed/added props (since people could add/remove all they want in one request)
-                _removedProperties.RemoveAll(s => s == alias);
-                _addedProperties.RemoveAll(s => s == alias);
-
-                //add to the added props
-                _addedProperties.Add(alias);
+                if (_addedProperties.Contains(alias) == false)
+                {
+                    //add to the added props
+                    _addedProperties.Add(alias);
+                }
             }
             else if (e.Action == NotifyCollectionChangedAction.Remove)
             {
@@ -153,12 +152,10 @@ namespace Umbraco.Core.Models
 
                 var alias = prop.Alias;
 
-                //remove from the removed/added props (since people could add/remove all they want in one request)
-                _removedProperties.RemoveAll(s => s == alias);
-                _addedProperties.RemoveAll(s => s == alias);
-
-                //add to the added props
-                _removedProperties.Add(alias);
+                if (_removedProperties.Contains(alias) == false)
+                {
+                    _removedProperties.Add(alias);
+                }
             }
         }
 
@@ -404,7 +401,8 @@ namespace Umbraco.Core.Models
 
             clone._addedProperties = new List<string>();
             clone._removedProperties = new List<string>();
-            clone._properties = new MacroPropertyCollection();
+            clone._properties = (MacroPropertyCollection)Properties.DeepClone();
+            //re-assign the event handler
             clone._properties.CollectionChanged += clone.PropertiesChanged;
 
             clone.ResetDirtyProperties(false);

src/Umbraco.Core/Models/MacroProperty.cs

@@ -11,7 +11,7 @@ namespace Umbraco.Core.Models
     /// </summary>
     [Serializable]
     [DataContract(IsReference = true)]
-    public class MacroProperty : TracksChangesEntityBase, IMacroProperty, IRememberBeingDirty
+    public class MacroProperty : TracksChangesEntityBase, IMacroProperty, IRememberBeingDirty, IDeepCloneable
     {
         public MacroProperty()
         {
@@ -176,5 +176,37 @@ namespace Umbraco.Core.Models
                 }, _editorAlias, PropertyTypeSelector);
             }
         }
+
+        public object DeepClone()
+        {
+            //Memberwise clone on MacroProperty will work since it doesn't have any deep elements
+            // for any sub class this will work for standard properties as well that aren't complex object's themselves.
+            var clone = (MacroProperty)MemberwiseClone();
+            //Automatically deep clone ref properties that are IDeepCloneable
+            DeepCloneHelper.DeepCloneRefProperties(this, clone);
+            clone.ResetDirtyProperties(false);
+            return clone;
+        }
+
+        protected bool Equals(MacroProperty other)
+        {
+            return string.Equals(_alias, other._alias) && _id == other._id;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((MacroProperty) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return ((_alias != null ? _alias.GetHashCode() : 0)*397) ^ _id;
+            }
+        }
     }
 }

src/Umbraco.Core/Models/MacroPropertyCollection.cs

@@ -8,13 +8,60 @@ namespace Umbraco.Core.Models
     /// <summary>
     /// A macro's property collection
     /// </summary>
-    public class MacroPropertyCollection : ObservableDictionary<string, IMacroProperty>
+    public class MacroPropertyCollection : ObservableDictionary<string, IMacroProperty>, IDeepCloneable
     {
         public MacroPropertyCollection() 
             : base(property => property.Alias)
         {
         }
 
+        public object DeepClone()
+        {
+            var clone = new MacroPropertyCollection();
+            foreach (var item in this)
+            {
+                clone.Add((IMacroProperty)item.DeepClone());
+            }
+            return clone;
+        }
+
+        /// <summary>
+        /// Used to update an existing macro property
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="sortOrder"></param>
+        /// <param name="editorAlias"></param>
+        /// <param name="currentAlias">
+        /// The existing property alias
+        /// </param>
+        /// <param name="newAlias"></param>        
+        public void UpdateProperty(string currentAlias, string name = null, int? sortOrder = null, string editorAlias = null, string newAlias = null)
+        {
+            var prop = this[currentAlias];
+            if (prop == null)
+            {
+                throw new InvalidOperationException("No property exists with alias " + currentAlias);
+            }
+
+            if (name.IsNullOrWhiteSpace() == false)
+            {
+                prop.Name = name;    
+            }
+            if (sortOrder.HasValue)
+            {
+                prop.SortOrder = sortOrder.Value;
+            }
+            if (name.IsNullOrWhiteSpace() == false)
+            {
+                prop.EditorAlias = editorAlias;
+            }
+
+            if (newAlias.IsNullOrWhiteSpace() == false && currentAlias != newAlias)
+            {
+                prop.Alias = newAlias;
+                ChangeKey(currentAlias, newAlias);
+            }
+        }
     }
 
 }

src/Umbraco.Core/Models/PreValue.cs

@@ -3,7 +3,7 @@
     /// <summary>
     /// Represents a stored pre-value field value
     /// </summary>
-    public class PreValue
+    public class PreValue : IDeepCloneable
     {
         public PreValue(int id, string value, int sortOrder)
         {
@@ -37,5 +37,12 @@
         /// The sort order stored for the pre-value field value
         /// </summary>
         public int SortOrder { get; private set; }
+
+        public virtual object DeepClone()
+        {
+            //Memberwise clone on PreValue will work since it doesn't have any deep elements
+            var clone = (PreValue)MemberwiseClone();            
+            return clone;
+        }
     }
 }

src/Umbraco.Core/Models/PreValueCollection.cs

@@ -14,7 +14,7 @@ namespace Umbraco.Core.Models
     /// Most legacy property editors won't support the dictionary format but new property editors should always use the dictionary format.
     /// In order to get overrideable pre-values working we need a dictionary since we'll have to reference a pre-value by a key.
     /// </remarks>
-    public class PreValueCollection
+    public class PreValueCollection : IDeepCloneable
     {
         private IDictionary<string, PreValue> _preValuesAsDictionary;
         private IEnumerable<PreValue> _preValuesAsArray;
@@ -82,5 +82,21 @@ namespace Umbraco.Core.Models
             }
             return result;
         }
+
+        public object DeepClone()
+        {
+            var clone = (PreValueCollection) MemberwiseClone();
+            if (_preValuesAsArray != null)
+            {
+                clone._preValuesAsArray = _preValuesAsArray.Select(x => (PreValue)x.DeepClone()).ToArray();    
+            }
+            if (_preValuesAsDictionary != null)
+            {
+                clone._preValuesAsDictionary = _preValuesAsDictionary.ToDictionary(x => x.Key, x => (PreValue)x.Value.DeepClone());    
+            }
+            
+
+            return clone;
+        }
     }
 }

src/Umbraco.Core/Models/PropertyTagBehavior.cs

@@ -0,0 +1,9 @@
+namespace Umbraco.Core.Models
+{
+    internal enum PropertyTagBehavior
+    {
+        Replace,
+        Remove,
+        Merge
+    }
+}

src/Umbraco.Core/Models/PropertyTags.cs

@@ -33,11 +33,4 @@ namespace Umbraco.Core.Models
         public IEnumerable<Tuple<string, string>> Tags { get; set; }
 
     }
-
-    internal enum PropertyTagBehavior
-    {
-        Replace,
-        Remove,
-        Merge
-    }
 }

src/Umbraco.Core/Models/PropertyTypeCollection.cs

@@ -83,6 +83,14 @@ namespace Umbraco.Core.Models
                         return;
                     }
                 }
+
+                //check if the item's sort order is already in use				
+                if (this.Any(x => x.SortOrder == item.SortOrder))
+                {
+                    //make it the next iteration
+                    item.SortOrder = this.Max(x => x.SortOrder) + 1;
+                }
+
                 base.Add(item);
                 OnAdd.IfNotNull(x => x.Invoke());//Could this not be replaced by a Mandate/Contract for ensuring item is not null
 

src/Umbraco.Core/Models/PublishedContent/IPublishedContentModelFactory.cs

@@ -3,7 +3,7 @@
     /// <summary>
     /// Provides the model creation service.
     /// </summary>
-    internal interface IPublishedContentModelFactory
+    public interface IPublishedContentModelFactory
     {
         /// <summary>
         /// Creates a strongly-typed model representing a published content.

src/Umbraco.Core/Models/PublishedContent/PublishedContentExtended.cs

@@ -51,7 +51,7 @@ namespace Umbraco.Core.Models.PublishedContent
             // a model, and then that model has to inherit from PublishedContentExtended,
             // => implements the internal IPublishedContentExtended.
 
-            var model = PublishedContentModelFactory.CreateModel(content);
+            var model = content.CreateModel();
             var extended = model == content // == means the factory did not create a model
               ? new PublishedContentExtended(content) // so we have to extend
               : model; // else we can use what the factory returned

src/Umbraco.Core/Models/PublishedContent/PublishedContentExtensionsForModels.cs

@@ -0,0 +1,20 @@
+namespace Umbraco.Core.Models.PublishedContent
+{
+    /// <summary>
+    /// Provides strongly typed published content models services.
+    /// </summary>
+    internal static class PublishedContentExtensionsForModels
+    {
+        /// <summary>
+        /// Creates a strongly typed published content model for an internal published content.
+        /// </summary>
+        /// <param name="content">The internal published content.</param>
+        /// <returns>The strongly typed published content model.</returns>
+        public static IPublishedContent CreateModel(this IPublishedContent content)
+        {
+            return PublishedContentModelFactoryResolver.Current.HasValue
+                ? PublishedContentModelFactoryResolver.Current.Factory.CreateModel(content)
+                : content;
+        }
+    }
+}

src/Umbraco.Core/Models/PublishedContent/PublishedContentModel.cs

@@ -10,7 +10,7 @@ namespace Umbraco.Core.Models.PublishedContent
     /// </summary>
     /// <remarks>Every strongly-typed published content class should inherit from <c>PublishedContentModel</c>
     /// (or inherit from a class that inherits from... etc.) so they are picked by the factory.</remarks>
-    internal abstract class PublishedContentModel : PublishedContentExtended
+    public abstract class PublishedContentModel : PublishedContentExtended
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="PublishedContentModel"/> class with

src/Umbraco.Core/Models/PublishedContent/PublishedContentModelAttribute.cs

@@ -8,7 +8,7 @@ namespace Umbraco.Core.Models.PublishedContent
     /// <remarks>By default, the name of the class is assumed to be the content type alias. The
     /// <c>PublishedContentModelAttribute</c> can be used to indicate a different alias.</remarks>
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
-    internal sealed class PublishedContentModelAttribute : Attribute
+    public sealed class PublishedContentModelAttribute : Attribute
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="PublishedContentModelAttribute"/> class with a content type alias.

src/Umbraco.Core/Models/PublishedContent/PublishedContentModelFactory.cs

@@ -1,20 +1,86 @@
-namespace Umbraco.Core.Models.PublishedContent
-{
-    /// <summary>
-    /// Provides strongly typed published content models services.
-    /// </summary>
-    internal static class PublishedContentModelFactory
-    {
-        /// <summary>
-        /// Creates a strongly typed published content model for an internal published content.
-        /// </summary>
-        /// <param name="content">The internal published content.</param>
-        /// <returns>The strongly typed published content model.</returns>
-        public static IPublishedContent CreateModel(IPublishedContent content)
-        {
-            return PublishedContentModelFactoryResolver.Current.HasValue
-                ? PublishedContentModelFactoryResolver.Current.Factory.CreateModel(content)
-                : content;
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+
+namespace Umbraco.Core.Models.PublishedContent
+{
+    /// <summary>
+    /// Implements a strongly typed content model factory
+    /// </summary>
+    public class PublishedContentModelFactory : IPublishedContentModelFactory
+    {
+        //private readonly Dictionary<string, ConstructorInfo> _constructors
+        //    = new Dictionary<string, ConstructorInfo>();
+
+        private readonly Dictionary<string, Func<IPublishedContent, IPublishedContent>> _constructors;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PublishedContentModelFactory"/> class with types.
+        /// </summary>
+        /// <param name="types">The model types.</param>
+        /// <remarks>
+        /// <para>Types must implement <c>IPublishedContent</c> and have a unique constructor that
+        /// accepts one IPublishedContent as a parameter.</para>
+        /// <para>To activate,</para>
+        /// <code>
+        /// var types = PluginManager.Current.ResolveTypes{PublishedContentModel}();
+        /// var factory = new PublishedContentModelFactoryImpl(types);
+        /// PublishedContentModelFactoryResolver.Current.SetFactory(factory);
+        /// </code>
+        /// </remarks>
+        public PublishedContentModelFactory(IEnumerable<Type> types)
+        {
+            var ctorArgTypes = new[] { typeof(IPublishedContent) };
+            var constructors = new Dictionary<string, Func<IPublishedContent, IPublishedContent>>();
+
+            foreach (var type in types)
+            {
+                var constructor = type.GetConstructor(ctorArgTypes);
+                if (constructor == null)
+                    throw new InvalidOperationException(string.Format("Type {0} is missing a public constructor with one argument of type IPublishedContent.", type.FullName));
+                var attribute = type.GetCustomAttribute<PublishedContentModelAttribute>(false);
+                var typeName = attribute == null ? type.Name : attribute.ContentTypeAlias;
+                typeName = typeName.ToLowerInvariant();
+
+                if (constructors.ContainsKey(typeName))
+                    throw new InvalidOperationException(string.Format("More that one type want to be a model for content type {0}.", typeName));
+
+                // should work everywhere, but slow
+                //_constructors[typeName] = constructor;
+
+                // much faster with a dynamic method but potential MediumTrust issues
+                // here http://stackoverflow.com/questions/16363838/how-do-you-call-a-constructor-via-an-expression-tree-on-an-existing-object
+
+                // fast enough and works in MediumTrust
+                // read http://boxbinary.com/2011/10/how-to-run-a-unit-test-in-medium-trust-with-nunitpart-three-umbraco-framework-testing/
+                var exprArg = Expression.Parameter(typeof(IPublishedContent), "content");
+                var exprNew = Expression.New(constructor, exprArg);
+                var expr = Expression.Lambda<Func<IPublishedContent, IPublishedContent>>(exprNew, exprArg);
+                var func = expr.Compile();
+                constructors[typeName] = func;
+            }
+
+            _constructors = constructors.Count > 0 ? constructors : null;
+        }
+
+        public IPublishedContent CreateModel(IPublishedContent content)
+        {
+            // fail fast
+            if (_constructors == null)
+                return content;
+
+            // be case-insensitive
+            var contentTypeAlias = content.DocumentTypeAlias.ToLowerInvariant();
+
+            //ConstructorInfo constructor;
+            //return _constructors.TryGetValue(contentTypeAlias, out constructor)
+            //    ? (IPublishedContent) constructor.Invoke(new object[] { content })
+            //    : content;
+
+            Func<IPublishedContent, IPublishedContent> constructor;
+            return _constructors.TryGetValue(contentTypeAlias, out constructor)
+                ? constructor(content)
+                : content;
+        }
+    }
+}

src/Umbraco.Core/Models/PublishedContent/PublishedContentModelFactoryImpl.cs

@@ -1,67 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-
-namespace Umbraco.Core.Models.PublishedContent
-{
-    /// <summary>
-    /// Implements a strongly typed content model factory
-    /// </summary>
-    internal class PublishedContentModelFactoryImpl : IPublishedContentModelFactory
-    {
-        //private readonly Dictionary<string, ConstructorInfo> _constructors
-        //    = new Dictionary<string, ConstructorInfo>();
-
-        private readonly Dictionary<string, Func<IPublishedContent, IPublishedContent>> _constructors
-             = new Dictionary<string, Func<IPublishedContent, IPublishedContent>>();
-
-        public PublishedContentModelFactoryImpl()
-        {
-            var types = PluginManager.Current.ResolveTypes<PublishedContentModel>();
-            var ctorArgTypes = new[] { typeof(IPublishedContent) };
-
-            foreach (var type in types)
-            {
-                var constructor = type.GetConstructor(ctorArgTypes);
-                if (constructor == null)
-                    throw new InvalidOperationException(string.Format("Type {0} is missing a public constructor with one argument of type IPublishedContent.", type.FullName));
-                var attribute = type.GetCustomAttribute<PublishedContentModelAttribute>(false);
-                var typeName = attribute == null ? type.Name : attribute.ContentTypeAlias;
-                typeName = typeName.ToLowerInvariant();
-
-                if (_constructors.ContainsKey(typeName))
-                    throw new InvalidOperationException(string.Format("More that one type want to be a model for content type {0}.", typeName));
-
-                // should work everywhere, but slow
-                //_constructors[typeName] = constructor;
-
-                // much faster with a dynamic method but potential MediumTrust issues
-                // here http://stackoverflow.com/questions/16363838/how-do-you-call-a-constructor-via-an-expression-tree-on-an-existing-object
-
-                // fast enough and works in MediumTrust
-                // read http://boxbinary.com/2011/10/how-to-run-a-unit-test-in-medium-trust-with-nunitpart-three-umbraco-framework-testing/
-                var exprArg = Expression.Parameter(typeof(IPublishedContent), "content");
-                var exprNew = Expression.New(constructor, exprArg);
-                var expr = Expression.Lambda<Func<IPublishedContent, IPublishedContent>>(exprNew, exprArg);
-                var func = expr.Compile();
-                _constructors[typeName] = func;
-            }
-        }
-
-        public IPublishedContent CreateModel(IPublishedContent content)
-        {
-            // be case-insensitive
-            var contentTypeAlias = content.DocumentTypeAlias.ToLowerInvariant();
-
-            //ConstructorInfo constructor;
-            //return _constructors.TryGetValue(contentTypeAlias, out constructor)
-            //    ? (IPublishedContent) constructor.Invoke(new object[] { content })
-            //    : content;
-
-            Func<IPublishedContent, IPublishedContent> constructor;
-            return _constructors.TryGetValue(contentTypeAlias, out constructor)
-                ? constructor(content)
-                : content;
-        }
-    }
-}

src/Umbraco.Core/Models/PublishedContent/PublishedContentModelFactoryResolver.cs

@@ -5,7 +5,7 @@ namespace Umbraco.Core.Models.PublishedContent
     /// <summary>
     /// Resolves the IPublishedContentModelFactory object.
     /// </summary>
-    internal class PublishedContentModelFactoryResolver : SingleObjectResolverBase<PublishedContentModelFactoryResolver, IPublishedContentModelFactory>
+    public class PublishedContentModelFactoryResolver : SingleObjectResolverBase<PublishedContentModelFactoryResolver, IPublishedContentModelFactory>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="PublishedContentModelFactoryResolver"/>.

src/Umbraco.Core/Models/PublishedContent/PublishedContentType.cs

@@ -44,6 +44,11 @@ namespace Umbraco.Core.Models.PublishedContent
             InitializeIndexes();
         }
 
+        // create detached content type - ie does not match anything in the DB
+        internal PublishedContentType(string alias, IEnumerable<PublishedPropertyType> propertyTypes)
+            : this (0, alias, propertyTypes)
+        { }
+
         private void InitializeIndexes()
         {
             for (var i = 0; i < _propertyTypes.Length; i++)

src/Umbraco.Core/Models/PublishedContent/PublishedPropertyType.cs

@@ -222,19 +222,38 @@ namespace Umbraco.Core.Models.PublishedContent
                 }
                 
             }
-            
+
+            var converterMeta = _converter as IPropertyValueConverterMeta;
+
             // get the cache levels, quietely fixing the inconsistencies (no need to throw, really)
-            _sourceCacheLevel = GetCacheLevel(_converter, PropertyCacheValue.Source);
-            _objectCacheLevel = GetCacheLevel(_converter, PropertyCacheValue.Object);
-            _objectCacheLevel = GetCacheLevel(_converter, PropertyCacheValue.XPath);
+            if (converterMeta != null)
+            {
+                _sourceCacheLevel = converterMeta.GetPropertyCacheLevel(this, PropertyCacheValue.Source);
+                _objectCacheLevel = converterMeta.GetPropertyCacheLevel(this, PropertyCacheValue.Object);
+                _objectCacheLevel = converterMeta.GetPropertyCacheLevel(this, PropertyCacheValue.XPath);
+            }
+            else
+            {
+                _sourceCacheLevel = GetCacheLevel(_converter, PropertyCacheValue.Source);
+                _objectCacheLevel = GetCacheLevel(_converter, PropertyCacheValue.Object);
+                _objectCacheLevel = GetCacheLevel(_converter, PropertyCacheValue.XPath);
+            }
             if (_objectCacheLevel < _sourceCacheLevel) _objectCacheLevel = _sourceCacheLevel;
             if (_xpathCacheLevel < _sourceCacheLevel) _xpathCacheLevel = _sourceCacheLevel;
 
+            // get the CLR type of the converted value
             if (_converter != null)
             {
-                var attr = _converter.GetType().GetCustomAttribute<PropertyValueTypeAttribute>(false);
-                if (attr != null)
-                    _clrType = attr.Type;
+                if (converterMeta != null)
+                {
+                    _clrType = converterMeta.GetPropertyValueType(this);
+                }
+                else
+                {
+                    var attr = _converter.GetType().GetCustomAttribute<PropertyValueTypeAttribute>(false);
+                    if (attr != null)
+                        _clrType = attr.Type;
+                }
             }
         }
 

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

@@ -9,7 +9,7 @@ namespace Umbraco.Core.Models.Rdbms
     internal class DataTypePreValueDto
     {
         [Column("id")]
-        [PrimaryKeyColumn(IdentitySeed = 5)]
+        [PrimaryKeyColumn(IdentitySeed = 6)]
         public int Id { get; set; }
 
         [Column("datatypeNodeId")]

src/Umbraco.Core/Models/TagCacheStorageType.cs

@@ -0,0 +1,8 @@
+namespace Umbraco.Core.Models
+{
+    public enum TagCacheStorageType
+    {
+        Csv,
+        Json
+    }
+}

src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs

@@ -49,6 +49,7 @@ namespace Umbraco.Core.ObjectResolution
         /// Initializes a new instance of the <see cref="LazyManyObjectsResolverBase{TResolver, TResolved}"/> class with an initial list
         /// <remarks>If <paramref name="scope"/> is per HttpRequest then there must be a current HttpContext.</remarks>
         /// <exception cref="InvalidOperationException"><paramref name="scope"/> is per HttpRequest but the current HttpContext is null.</exception>
+        /// </summary>
         protected LazyManyObjectsResolverBase(IEnumerable<Lazy<Type>> lazyTypeList, ObjectLifetimeScope scope = ObjectLifetimeScope.Application)
 			: this(scope)
 		{			
@@ -108,7 +109,7 @@ namespace Umbraco.Core.ObjectResolution
 		/// Gets a value indicating whether the resolver has resolved types to create instances from.
 		/// </summary>
         /// <remarks>To be used in unit tests.</remarks>
-		internal bool HasResolvedTypes
+		public bool HasResolvedTypes
 		{
 			get
             {

src/Umbraco.Core/ObservableDictionary.cs

@@ -135,6 +135,28 @@ namespace Umbraco.Core
 
         }
 
+        /// <summary>
+        /// Allows us to change the key of an item
+        /// </summary>
+        /// <param name="currentKey"></param>
+        /// <param name="newKey"></param>
+        public virtual void ChangeKey(TKey currentKey, TKey newKey)
+        {
+            if (!Indecies.ContainsKey(currentKey))
+            {
+                throw new InvalidOperationException("No item with the key " + currentKey + "was found in the collection");
+            }
+            if (ContainsKey(newKey))
+            {
+                throw new DuplicateKeyException(newKey.ToString());
+            }
+
+            var currentIndex = Indecies[currentKey];
+
+            Indecies.Remove(currentKey);
+            Indecies.Add(newKey, currentIndex);
+        }
+
         internal class DuplicateKeyException : Exception
         {
 

src/Umbraco.Core/Persistence/Caching/RuntimeCacheProvider.cs

@@ -128,9 +128,9 @@ namespace Umbraco.Core.Persistence.Caching
         public void Save(Type type, IEntity entity)
         {
             //IMPORTANT: we must clone to store, see: http://issues.umbraco.org/issue/U4-4259
-            entity = (IEntity)entity.DeepClone();
+            var clone = (IEntity)entity.DeepClone();
 
-            var key = GetCompositeId(type, entity.Id);
+            var key = GetCompositeId(type, clone.Id);
             
             _keyTracker.TryAdd(key);
 
@@ -139,11 +139,11 @@ namespace Umbraco.Core.Persistence.Caching
 
             if (_memoryCache != null)
             {
-                _memoryCache.Set(key, entity, new CacheItemPolicy { SlidingExpiration = TimeSpan.FromMinutes(5) });
+                _memoryCache.Set(key, clone, new CacheItemPolicy { SlidingExpiration = TimeSpan.FromMinutes(5) });
             }
             else
             {
-                HttpRuntime.Cache.Insert(key, entity, null, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(5));
+                HttpRuntime.Cache.Insert(key, clone, null, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(5));
             }
         }
 

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

@@ -248,6 +248,9 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
         {
             _database.Insert("cmsDataTypePreValues", "id", false, new DataTypePreValueDto { Id = 3, Alias = "", SortOrder = 0, DataTypeNodeId = -87, Value = ",code,undo,redo,cut,copy,mcepasteword,stylepicker,bold,italic,bullist,numlist,outdent,indent,mcelink,unlink,mceinsertanchor,mceimage,umbracomacro,mceinserttable,umbracoembed,mcecharmap,|1|1,2,3,|0|500,400|1049,|true|" });
             _database.Insert("cmsDataTypePreValues", "id", false, new DataTypePreValueDto { Id = 4, Alias = "group", SortOrder = 0, DataTypeNodeId = 1041, Value = "default" });
+
+            //default's for MultipleMediaPickerAlias picker
+            _database.Insert("cmsDataTypePreValues", "id", false, new DataTypePreValueDto { Id = 5, Alias = "multiPicker", SortOrder = 0, DataTypeNodeId = 1045, Value = "1" });
         }
 
         private void CreateUmbracoRelationTypeData()

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionFourNineZero/RemoveUmbracoAppConstraints.cs

@@ -1,5 +1,7 @@
 using System.Data;
+using System.Linq;
 using Umbraco.Core.Configuration;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionFourNineZero
 {
@@ -18,9 +20,18 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionFourNineZero
             }
             else
             {
-                //These are the old aliases
-                Delete.ForeignKey("FK_umbracoUser2app_umbracoApp").OnTable("umbracoUser2app");
-                Delete.ForeignKey("FK_umbracoUser2app_umbracoUser").OnTable("umbracoUser2app");
+                //These are the old aliases, before removing them, check they exist
+                var constraints = SqlSyntaxContext.SqlSyntaxProvider.GetConstraintsPerColumn(Context.Database).Distinct().ToArray();
+
+                if (constraints.Any(x => x.Item1.InvariantEquals("umbracoUser2app") && x.Item3.InvariantEquals("FK_umbracoUser2app_umbracoApp")))
+                {
+                    Delete.ForeignKey("FK_umbracoUser2app_umbracoApp").OnTable("umbracoUser2app");    
+                }
+                if (constraints.Any(x => x.Item1.InvariantEquals("umbracoUser2app") && x.Item3.InvariantEquals("FK_umbracoUser2app_umbracoUser")))
+                {
+                    Delete.ForeignKey("FK_umbracoUser2app_umbracoUser").OnTable("umbracoUser2app");
+                }
+                
             }
             
         }

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

@@ -240,7 +240,7 @@ AND umbracoNode.id <> @id",
                         {
                             var nodeId = contentDto.NodeId;
                             var propertyTypeId = propertyType.Id;
-                            var propertySql = new Sql().Select("*")
+                            var propertySql = new Sql().Select("cmsPropertyData.id")
                                                        .From<PropertyDataDto>()
                                                        .InnerJoin<PropertyTypeDto>()
                                                        .On<PropertyDataDto, PropertyTypeDto>(
@@ -249,7 +249,7 @@ AND umbracoNode.id <> @id",
                                                        .Where<PropertyTypeDto>(x => x.Id == propertyTypeId);
 
                             //Finally delete the properties that match our criteria for removing a ContentType from the composition
-                            Database.Delete<PropertyDataDto>(propertySql);
+                            Database.Delete<PropertyDataDto>(new Sql("WHERE id IN (" + propertySql.SQL + ")", propertySql.Arguments));
                         }
                     }
                 }
@@ -285,7 +285,8 @@ AND umbracoNode.id <> @id",
                 }
             }
 
-            if (((ICanBeDirty) entity).IsPropertyDirty("PropertyGroups") || entity.PropertyGroups.Any(x => x.IsDirty()))
+            if (((ICanBeDirty)entity).IsPropertyDirty("PropertyGroups") || 
+                entity.PropertyGroups.Any(x => x.IsDirty()))
             {
                 //Delete Tabs/Groups by excepting entries from db with entries from collections
                 var dbPropertyGroups =
@@ -346,6 +347,25 @@ AND umbracoNode.id <> @id",
                 if (propertyType.HasIdentity == false)
                     propertyType.Id = typePrimaryKey; //Set Id on new PropertyType
             }
+
+            //If a Composition is removed we need to update/reset references to the PropertyGroups on that ContentType
+            if (((ICanBeDirty)entity).IsPropertyDirty("ContentTypeComposition") &&
+                compositionBase != null &&
+                compositionBase.RemovedContentTypeKeyTracker != null &&
+                compositionBase.RemovedContentTypeKeyTracker.Any())
+            {
+                foreach (var compositionId in compositionBase.RemovedContentTypeKeyTracker)
+                {
+                    var dbPropertyGroups =
+                        Database.Fetch<PropertyTypeGroupDto>("WHERE contenttypeNodeId = @Id", new { Id = compositionId })
+                            .Select(x => x.Id);
+                    foreach (var propertyGroup in dbPropertyGroups)
+                    {
+                        Database.Update<PropertyTypeGroupDto>("SET parentGroupId = NULL WHERE parentGroupId = @TabId AND contenttypeNodeId = @ContentTypeNodeId",
+                                                              new { TabId = propertyGroup, ContentTypeNodeId = entity.Id });
+                    }
+                }
+            }
         }
 
         protected IEnumerable<ContentTypeSort> GetAllowedContentTypeIds(int id)

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

@@ -295,8 +295,8 @@ AND umbracoNode.id <> @id",
                 var cached = _cacheHelper.RuntimeCache.GetCacheItemsByKeySearch<PreValueCollection>(GetPrefixedCacheKey(dataTypeId));
                 if (cached != null && cached.Any())
                 {
-                    //return from the cache
-                    return cached.First();
+                    //return from the cache, ensure it's a cloned result
+                    return (PreValueCollection)cached.First().DeepClone();
                 }
 
                 l.UpgradeToWriteLock();

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

@@ -493,14 +493,17 @@ namespace Umbraco.Core.Persistence.Repositories
                 // Is this the same UmbracoEntity as the current one we're processing
                 if (Current != null && Current.Key == a.uniqueID)
                 {
-                    // Add this UmbracoProperty to the current additional data
-                    Current.AdditionalData[p.PropertyAlias] = new UmbracoEntity.EntityProperty
+                    if (p != null && p.PropertyAlias.IsNullOrWhiteSpace() == false)
                     {
-                        PropertyEditorAlias = p.PropertyEditorAlias,
-                        Value = p.NTextValue.IsNullOrWhiteSpace() 
-                            ? p.NVarcharValue 
-                            : p.NTextValue.ConvertToJsonIfPossible()
-                    };
+                        // Add this UmbracoProperty to the current additional data
+                        Current.AdditionalData[p.PropertyAlias] = new UmbracoEntity.EntityProperty
+                        {
+                            PropertyEditorAlias = p.PropertyEditorAlias,
+                            Value = p.NTextValue.IsNullOrWhiteSpace()
+                                ? p.NVarcharValue
+                                : p.NTextValue.ConvertToJsonIfPossible()
+                        };    
+                    }
 
                     // Return null to indicate we're not done with this UmbracoEntity yet
                     return null;
@@ -516,14 +519,17 @@ namespace Umbraco.Core.Persistence.Repositories
                 
                 Current = _factory.BuildEntityFromDynamic(a);
 
-                //add the property/create the prop list if null
-                Current.AdditionalData[p.PropertyAlias] = new UmbracoEntity.EntityProperty
+                if (p != null && p.PropertyAlias.IsNullOrWhiteSpace() == false)
                 {
-                    PropertyEditorAlias = p.PropertyEditorAlias,
-                    Value = p.NTextValue.IsNullOrWhiteSpace()
-                        ? p.NVarcharValue
-                        : p.NTextValue.ConvertToJsonIfPossible()
-                };
+                    //add the property/create the prop list if null
+                    Current.AdditionalData[p.PropertyAlias] = new UmbracoEntity.EntityProperty
+                    {
+                        PropertyEditorAlias = p.PropertyEditorAlias,
+                        Value = p.NTextValue.IsNullOrWhiteSpace()
+                            ? p.NVarcharValue
+                            : p.NTextValue.ConvertToJsonIfPossible()
+                    };
+                }
 
                 // Return the now populated previous UmbracoEntity (or null if first time through)
                 return prev;

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

@@ -165,10 +165,18 @@ namespace Umbraco.Core.Persistence.Repositories
 
             Database.Update(dto);
 
-            //update the sections if they've changed
+            //update the properties if they've changed
             var macro = (Macro)entity;
-            if (macro.IsPropertyDirty("Properties"))
+            if (macro.IsPropertyDirty("Properties") || macro.Properties.Any(x => x.IsDirty()))
             {
+                //now we need to delete any props that have been removed
+                foreach (var propAlias in macro.RemovedProperties)
+                {
+                    //delete the property
+                    Database.Delete<MacroPropertyDto>("WHERE macro=@macroId AND macroPropertyAlias=@propAlias",
+                        new { macroId = macro.Id, propAlias = propAlias });
+                }
+
                 //for any that exist on the object, we need to determine if we need to update or insert
                 foreach (var propDto in dto.MacroPropertyDtos)
                 {
@@ -180,17 +188,15 @@ namespace Umbraco.Core.Persistence.Repositories
                     }
                     else
                     {
-                        Database.Update(propDto);
+                        //only update if it's dirty
+                        if (macro.Properties[propDto.Alias].IsDirty())
+                        {
+                            Database.Update(propDto);    
+                        }
                     }
                 }
 
-                //now we need to delete any props that have been removed
-                foreach (var propAlias in macro.RemovedProperties)
-                {
-                    //delete the property
-                    Database.Delete<MacroPropertyDto>("WHERE macro=@macroId AND macroPropertyAlias=@propAlias",
-                        new { macroId = macro.Id, propAlias = propAlias });
-                }
+                
             }
 
             ((ICanBeDirty)entity).ResetDirtyProperties();

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

@@ -285,7 +285,7 @@ namespace Umbraco.Core.Persistence.Repositories
             if (group.IsNullOrWhiteSpace() == false)
             {
                 sql = sql.Where<TagDto>(dto => dto.Group == group);
-            }  
+            }
 
             var factory = new TagFactory();
 
@@ -329,7 +329,7 @@ namespace Umbraco.Core.Persistence.Repositories
             //NOTE: There's some very clever logic in the umbraco.cms.businesslogic.Tags.Tag to insert tags where they don't exist, 
             // and assign where they don't exist which we've borrowed here. The queries are pretty zany but work, otherwise we'll end up 
             // with quite a few additional queries.
-            
+
             //do all this in one transaction
             using (var trans = Database.GetTransaction())
             {
@@ -397,7 +397,7 @@ namespace Umbraco.Core.Persistence.Repositories
         public void RemoveTagsFromProperty(int contentId, int propertyTypeId, IEnumerable<ITag> tags)
         {
             var tagSetSql = GetTagSet(tags);
-            
+
             var deleteSql = string.Concat("DELETE FROM cmsTagRelationship WHERE nodeId = ",
                                           contentId,
                                           " AND propertyTypeId = ",
@@ -439,7 +439,11 @@ namespace Umbraco.Core.Persistence.Repositories
         /// <returns></returns>
         private static string GetTagSet(IEnumerable<ITag> tagsToInsert)
         {
-            var array = tagsToInsert.Select(tag => string.Format("select '{0}' as Tag, '{1}' as [Group]", tag.Text.Replace("'", "''"), tag.Group)).ToArray();
+            var array = tagsToInsert
+                .Select(tag =>
+                    string.Format("select '{0}' as Tag, '{1}' as [Group]",
+                        PetaPocoExtensions.EscapeAtSymbols(tag.Text.Replace("'", "''")), tag.Group))
+                .ToArray();
             return "(" + string.Join(" union ", array).Replace("  ", " ") + ") as TagSet";
         }
 

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

@@ -158,7 +158,7 @@ namespace Umbraco.Core.Persistence.Repositories
                            {
                                "DELETE FROM umbracoUser2NodeNotify WHERE nodeId = @Id",
                                "DELETE FROM umbracoUser2NodePermission WHERE nodeId = @Id",
-                               "UPDATE cmsDocument SET templateId = NULL WHERE nodeId = @Id",
+                               "UPDATE cmsDocument SET templateId = NULL WHERE templateId = @Id",
                                "DELETE FROM cmsDocumentType WHERE templateNodeId = @Id",
                                "DELETE FROM cmsTemplate WHERE nodeId = @Id",
                                "DELETE FROM umbracoNode WHERE id = @Id"
@@ -371,7 +371,6 @@ namespace Umbraco.Core.Persistence.Repositories
             //template.CreateDate = _viewsFileSystem.GetCreated(path).UtcDateTime;
             //template.Key = new FileInfo(path).Name.EncodeAsGuid();
 
-            template.Path = path;
             template.Content = content;
         }
 

src/Umbraco.Core/PluginManager.cs

@@ -44,9 +44,9 @@ namespace Umbraco.Core
         /// file is cached temporarily until app startup completes.
         /// </summary>
         /// <param name="appContext"></param>
-        /// <param name="detectBinChanges"></param>
-        internal PluginManager(ApplicationContext appContext, bool detectBinChanges = true)
-            : this(detectBinChanges)
+        /// <param name="detectChanges"></param>
+        internal PluginManager(ApplicationContext appContext, bool detectChanges = true)
+            : this(detectChanges)
         {
             if (appContext == null) throw new ArgumentNullException("appContext");
             _appContext = appContext;
@@ -55,11 +55,11 @@ namespace Umbraco.Core
         /// <summary>
         /// Creates a new PluginManager
         /// </summary>
-        /// <param name="detectCodeChanges">
-        /// If true will detect changes in the /bin folder and therefor load plugins from the 
+        /// <param name="detectChanges">
+        /// If true will detect changes in the /bin folder, app_code, etc... and therefor load plugins from the 
         /// cached plugins file if one is found. If false will never use the cache file for plugins
         /// </param>
-        internal PluginManager(bool detectCodeChanges = true)
+        internal PluginManager(bool detectChanges = true)
         {
             _tempFolder = IOHelper.MapPath("~/App_Data/TEMP/PluginCache");
             //create the folder if it doesn't exist
@@ -68,29 +68,41 @@ namespace Umbraco.Core
                 Directory.CreateDirectory(_tempFolder);
             }
 
+            var pluginListFile = GetPluginListFilePath();
+
             //this is a check for legacy changes, before we didn't store the TypeResolutionKind in the file which was a mistake,
             //so we need to detect if the old file is there without this attribute, if it is then we delete it
             if (DetectLegacyPluginListFile())
             {
-                var filePath = GetPluginListFilePath();
-                File.Delete(filePath);
+                File.Delete(pluginListFile);
             }
 
-            if (detectCodeChanges)
+            if (detectChanges)
             {
                 //first check if the cached hash is 0, if it is then we ne
                 //do the check if they've changed
-                HaveAssembliesChanged = (CachedAssembliesHash != CurrentAssembliesHash) || CachedAssembliesHash == 0;
+                RequiresRescanning = (CachedAssembliesHash != CurrentAssembliesHash) || CachedAssembliesHash == 0;
                 //if they have changed, we need to write the new file
-                if (HaveAssembliesChanged)
+                if (RequiresRescanning)
                 {
+                    //if the hash has changed, clear out the persisted list no matter what, this will force
+                    // rescanning of all plugin types including lazy ones.
+                    // http://issues.umbraco.org/issue/U4-4789
+                    File.Delete(pluginListFile);
+
                     WriteCachePluginsHash();
                 }
             }
             else
             {
+
+                //if the hash has changed, clear out the persisted list no matter what, this will force
+                // rescanning of all plugin types including lazy ones.
+                // http://issues.umbraco.org/issue/U4-4789
+                File.Delete(pluginListFile);
+
                 //always set to true if we're not detecting (generally only for testing)
-                HaveAssembliesChanged = true;
+                RequiresRescanning = true;
             }
 
         }
@@ -130,9 +142,9 @@ namespace Umbraco.Core
 
 
         /// <summary>
-        /// Returns a bool if the assemblies in the /bin have changed since they were last hashed.
+        /// Returns a bool if the assemblies in the /bin, app_code, global.asax, etc... have changed since they were last hashed.
         /// </summary>
-        internal bool HaveAssembliesChanged { get; private set; }
+        internal bool RequiresRescanning { get; private set; }
 
         /// <summary>
         /// Returns the currently cached hash value of the scanned assemblies in the /bin folder. Returns 0 
@@ -328,7 +340,7 @@ namespace Umbraco.Core
         /// <remarks>
         /// Generally only used for resetting cache, for example during the install process
         /// </remarks>
-        internal void ClearPluginCache()
+        public void ClearPluginCache()
         {
             var path = GetPluginListFilePath();
             if (File.Exists(path))
@@ -670,7 +682,7 @@ namespace Umbraco.Core
 
                         //we first need to look into our cache file (this has nothing to do with the 'cacheResult' parameter which caches in memory).
                         //if assemblies have not changed and the cache file actually exists, then proceed to try to lookup by the cache file.
-                        if (HaveAssembliesChanged == false && File.Exists(GetPluginListFilePath()))
+                        if (RequiresRescanning == false && File.Exists(GetPluginListFilePath()))
                         {
                             var fileCacheResult = TryGetCachedPluginsFromFile<T>(resolutionType);
 

src/Umbraco.Core/Profiling/WebProfiler.cs

@@ -82,9 +82,16 @@ namespace Umbraco.Core.Profiling
                 return false;
 
             var request = TryGetRequest(sender);
-            if (request.Success == false || request.Result.Url.IsClientSideRequest() || string.IsNullOrEmpty(request.Result["umbDebug"]))
+
+            if (request.Success == false || request.Result.Url.IsClientSideRequest())
                 return false;
-            
+
+            if (string.IsNullOrEmpty(request.Result["umbDebug"]))
+                return true;
+
+            if (request.Result.Url.IsBackOfficeRequest(HttpRuntime.AppDomainAppVirtualPath))
+                return true;
+
             return true;
         }
 
@@ -97,7 +104,7 @@ namespace Umbraco.Core.Profiling
         /// </remarks>
         public string Render()
         {
-            return MiniProfiler.RenderIncludes().ToString();
+            return MiniProfiler.RenderIncludes(RenderPosition.Right).ToString();
         }
 
         /// <summary>

src/Umbraco.Core/Properties/AssemblyInfo.cs

@@ -22,6 +22,7 @@ using System.Security.Permissions;
 
 [assembly: InternalsVisibleTo("umbraco")]
 [assembly: InternalsVisibleTo("Umbraco.Tests")]
+[assembly: InternalsVisibleTo("Umbraco.Extensions")]
 [assembly: InternalsVisibleTo("businesslogic")]
 [assembly: InternalsVisibleTo("cms")]
 [assembly: InternalsVisibleTo("umbraco.editorControls")]

src/Umbraco.Core/PropertyEditors/IPropertyValueConverterMeta.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Umbraco.Core.Models.PublishedContent;
+
+namespace Umbraco.Core.PropertyEditors
+{
+    /// <summary>
+    /// Provides published content properties converter meta data.
+    /// </summary>
+    public interface IPropertyValueConverterMeta : IPropertyValueConverter
+    {
+        /// <summary>
+        /// Gets the type of values returned by the converter.
+        /// </summary>
+        /// <param name="propertyType">The property type.</param>
+        /// <returns>The CLR type of values returned by the converter.</returns>
+        Type GetPropertyValueType(PublishedPropertyType propertyType);
+
+        /// <summary>
+        /// Gets the property cache level of a specified value.
+        /// </summary>
+        /// <param name="propertyType">The property type.</param>
+        /// <param name="cacheValue">The property value.</param>
+        /// <returns>The property cache level of the specified value.</returns>
+        PropertyCacheLevel GetPropertyCacheLevel(PublishedPropertyType propertyType, PropertyCacheValue cacheValue);
+    }
+}

src/Umbraco.Core/PropertyEditors/SupportTagsAttribute.cs

@@ -1,4 +1,5 @@
 using System;
+using Umbraco.Core.Models;
 
 namespace Umbraco.Core.PropertyEditors
 {
@@ -30,6 +31,7 @@ namespace Umbraco.Core.PropertyEditors
             Delimiter = ",";
             ReplaceTags = true;
             TagGroup = "default";
+            StorageType = TagCacheStorageType.Csv;
         }
 
         /// <summary>
@@ -37,6 +39,11 @@ namespace Umbraco.Core.PropertyEditors
         /// </summary>
         public TagValueType ValueType { get; set; }
 
+        /// <summary>
+        /// Defines how to store the tags in cache (CSV or Json)
+        /// </summary>
+        public TagCacheStorageType StorageType { get; set; }
+
         /// <summary>
         /// Defines a custom delimiter, the default is a comma
         /// </summary>

src/Umbraco.Core/PropertyEditors/TagPropertyDefinition.cs

@@ -1,4 +1,5 @@
-using Umbraco.Core.Models.Editors;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Editors;
 
 namespace Umbraco.Core.PropertyEditors
 {
@@ -30,8 +31,14 @@ namespace Umbraco.Core.PropertyEditors
             Delimiter = tagsAttribute.Delimiter;
             ReplaceTags = tagsAttribute.ReplaceTags;
             TagGroup = tagsAttribute.TagGroup;
+            StorageType = TagCacheStorageType.Csv;
         }
 
+        /// <summary>
+        /// Defines how to store the tags in cache (CSV or Json)
+        /// </summary>
+        public virtual TagCacheStorageType StorageType { get; private set; }
+
         /// <summary>
         /// Defines a custom delimiter, the default is a comma
         /// </summary>

src/Umbraco.Core/Security/AuthenticationExtensions.cs

@@ -86,6 +86,7 @@ namespace Umbraco.Core.Security
         public static UmbracoBackOfficeIdentity GetCurrentIdentity(this HttpContextBase http, bool authenticateRequestIfNotFound)
         {
             if (http == null) throw new ArgumentNullException("http");
+            if (http.User == null) return null; //there's no user at all so no identity
             var identity = http.User.Identity as UmbracoBackOfficeIdentity;
             if (identity != null) return identity;
             if (authenticateRequestIfNotFound == false) return null;

src/Umbraco.Core/Services/ContentService.cs

@@ -1224,8 +1224,8 @@ namespace Umbraco.Core.Services
             if (SendingToPublish.IsRaisedEventCancelled(new SendToPublishEventArgs<IContent>(content), this))
                 return false;
 
-            //TODO: Do some stuff here.. ... what is it supposed to do ?
-            // pretty sure all that legacy stuff did was raise an event? and we no longer have IActionHandlers so no worries there.
+            //Save before raising event
+            Save(content, userId);
 
             SentToPublish.RaiseEvent(new SendToPublishEventArgs<IContent>(content, false), this);
 

src/Umbraco.Core/Services/DataTypeService.cs

@@ -124,7 +124,9 @@ namespace Umbraco.Core.Services
             {
                 var collection = repository.GetPreValuesCollectionByDataTypeId(id);
                 //now convert the collection to a string list
-                var list = collection.FormatAsDictionary().Select(x => x.Value.Value).ToList();
+                var list = collection.FormatAsDictionary()
+                    .Select(x => x.Value.Value)
+                    .ToList();
                 return list;
             }
         }

src/Umbraco.Core/Services/EntityService.cs

@@ -367,8 +367,8 @@ namespace Umbraco.Core.Services
             using (var uow = _uowProvider.GetUnitOfWork())
             {
                 var sql = new Sql().Select("nodeObjectType").From<NodeDto>().Where<NodeDto>(x => x.NodeId == id);
-                var nodeObjectTypeId = uow.Database.ExecuteScalar<string>(sql);
-                var objectTypeId = new Guid(nodeObjectTypeId);
+                var nodeObjectTypeId = uow.Database.ExecuteScalar<Guid>(sql);
+                var objectTypeId = nodeObjectTypeId;
                 return UmbracoObjectTypesExtensions.GetUmbracoObjectType(objectTypeId);
             }
         }
@@ -383,8 +383,8 @@ namespace Umbraco.Core.Services
             using (var uow = _uowProvider.GetUnitOfWork())
             {
                 var sql = new Sql().Select("nodeObjectType").From<NodeDto>().Where<NodeDto>(x => x.UniqueId == key);
-                var nodeObjectTypeId = uow.Database.ExecuteScalar<string>(sql);
-                var objectTypeId = new Guid(nodeObjectTypeId);
+                var nodeObjectTypeId = uow.Database.ExecuteScalar<Guid>(sql);
+                var objectTypeId = nodeObjectTypeId;
                 return UmbracoObjectTypesExtensions.GetUmbracoObjectType(objectTypeId);
             }
         }

src/Umbraco.Core/Services/UserService.cs

@@ -207,10 +207,11 @@ namespace Umbraco.Core.Services
             if (user == null) throw new ArgumentNullException("user");
 
             var provider = MembershipProviderExtensions.GetUsersMembershipProvider();
-            if (provider.IsUmbracoMembershipProvider())
-            {
-                provider.ChangePassword(user.Username, "", password);
-            }
+
+            if (provider.IsUmbracoMembershipProvider() == false)
+                throw new NotSupportedException("When using a non-Umbraco membership provider you must change the user password by using the MembershipProvider.ChangePassword method");
+
+            provider.ChangePassword(user.Username, "", password);
 
             //go re-fetch the member and update the properties that may have changed
             var result = GetByUsername(user.Username);
@@ -221,8 +222,6 @@ namespace Umbraco.Core.Services
                 user.LastPasswordChangeDate = result.LastPasswordChangeDate;
                 user.UpdateDate = user.UpdateDate;
             }
-
-            throw new NotSupportedException("When using a non-Umbraco membership provider you must change the user password by using the MembershipProvider.ChangePassword method");
         }
 
         /// <summary>

src/Umbraco.Core/StringExtensions.cs

@@ -213,7 +213,7 @@ namespace Umbraco.Core
         //this is from SqlMetal and just makes it a bit of fun to allow pluralisation
         public static string MakePluralName(this string name)
         {
-            if ((name.EndsWith("x", StringComparison.OrdinalIgnoreCase) || name.EndsWith("ch", StringComparison.OrdinalIgnoreCase)) || (name.EndsWith("ss", StringComparison.OrdinalIgnoreCase) || name.EndsWith("sh", StringComparison.OrdinalIgnoreCase)))
+            if ((name.EndsWith("x", StringComparison.OrdinalIgnoreCase) || name.EndsWith("ch", StringComparison.OrdinalIgnoreCase)) || (name.EndsWith("s", StringComparison.OrdinalIgnoreCase) || name.EndsWith("sh", StringComparison.OrdinalIgnoreCase)))
             {
                 name = name + "es";
                 return name;

src/Umbraco.Core/Sync/DefaultServerMessenger.cs

@@ -4,6 +4,7 @@ using System.Globalization;
 using System.Linq;
 using System.Net;
 using System.Threading;
+using System.Web;
 using System.Web.Script.Serialization;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Configuration;
@@ -520,7 +521,7 @@ namespace Umbraco.Core.Sync
             }
         }
 
-        private IEnumerable<IAsyncResult> GetAsyncResults(List<IAsyncResult> asyncResultsList, out List<WaitHandle> waitHandlesList)
+        internal IEnumerable<IAsyncResult> GetAsyncResults(List<IAsyncResult> asyncResultsList, out List<WaitHandle> waitHandlesList)
         {
             var asyncResults = asyncResultsList.ToArray();
             waitHandlesList = new List<WaitHandle>();

src/Umbraco.Core/Sync/RefreshInstruction.cs

@@ -0,0 +1,63 @@
+using System;
+
+namespace Umbraco.Core.Sync
+{
+    [Serializable]
+    public class RefreshInstruction
+    {
+        public RefreshMethodType RefreshType { get; set; }
+        public Guid RefresherId { get; set; }
+        public Guid GuidId { get; set; }
+        public int IntId { get; set; }
+        public string JsonIds { get; set; }
+        public string JsonPayload { get; set; }
+
+        [Serializable]
+        public enum RefreshMethodType
+        {
+            RefreshAll,
+            RefreshByGuid,
+            RefreshById,
+            RefreshByIds,
+            RefreshByJson,
+            RemoveById
+        }
+
+        protected bool Equals(RefreshInstruction other)
+        {
+            return RefreshType == other.RefreshType && RefresherId.Equals(other.RefresherId) && GuidId.Equals(other.GuidId) && IntId == other.IntId && string.Equals(JsonIds, other.JsonIds) && string.Equals(JsonPayload, other.JsonPayload);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((RefreshInstruction) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hashCode = (int) RefreshType;
+                hashCode = (hashCode*397) ^ RefresherId.GetHashCode();
+                hashCode = (hashCode*397) ^ GuidId.GetHashCode();
+                hashCode = (hashCode*397) ^ IntId;
+                hashCode = (hashCode*397) ^ (JsonIds != null ? JsonIds.GetHashCode() : 0);
+                hashCode = (hashCode*397) ^ (JsonPayload != null ? JsonPayload.GetHashCode() : 0);
+                return hashCode;
+            }
+        }
+
+        public static bool operator ==(RefreshInstruction left, RefreshInstruction right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(RefreshInstruction left, RefreshInstruction right)
+        {
+            return !Equals(left, right);
+        }
+    }
+}

src/Umbraco.Core/Sync/ServerSyncWebServiceClient.cs

@@ -4,7 +4,6 @@ using Umbraco.Core.IO;
 
 namespace Umbraco.Core.Sync
 {
-    
     /// <summary>
     /// The client Soap service for making distrubuted cache calls between servers
     /// </summary>
@@ -21,6 +20,31 @@ namespace Umbraco.Core.Sync
 
         }
 
+        /// <remarks/>
+        [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://umbraco.org/webservices/BulkRefresh", RequestNamespace = "http://umbraco.org/webservices/", ResponseNamespace = "http://umbraco.org/webservices/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
+        public void BulkRefresh(RefreshInstruction[] instructions, string login, string password)
+        {
+            this.Invoke("BulkRefresh", new object[] {
+													   instructions,
+													   login,
+													   password});
+        }
+
+        /// <remarks/>
+        public System.IAsyncResult BeginBulkRefresh(RefreshInstruction[] instructions, string login, string password, System.AsyncCallback callback, object asyncState)
+        {
+            return this.BeginInvoke("BulkRefresh", new object[] {
+																   instructions,
+																   login,
+																   password}, callback, asyncState);
+        }
+
+        /// <remarks/>
+        public void EndBulkRefresh(System.IAsyncResult asyncResult)
+        {
+            this.EndInvoke(asyncResult);
+        }
+
         /// <remarks/>
         [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://umbraco.org/webservices/RefreshAll", RequestNamespace = "http://umbraco.org/webservices/", ResponseNamespace = "http://umbraco.org/webservices/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
         public void RefreshAll(System.Guid uniqueIdentifier, string Login, string Password)

src/Umbraco.Core/Umbraco.Core.csproj

@@ -55,7 +55,8 @@
       <Private>True</Private>
       <HintPath>..\packages\Microsoft.Web.Infrastructure.1.0.0.0\lib\net40\Microsoft.Web.Infrastructure.dll</HintPath>
     </Reference>
-    <Reference Include="MiniProfiler">
+    <Reference Include="MiniProfiler, Version=2.1.0.0, Culture=neutral, PublicKeyToken=b44f9351044011a3, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\MiniProfiler.2.1.0\lib\net40\MiniProfiler.dll</HintPath>
     </Reference>
     <Reference Include="MySql.Data">
@@ -315,6 +316,7 @@
     <Compile Include="Manifest\ManifestBuilder.cs" />
     <Compile Include="Manifest\ManifestParser.cs" />
     <Compile Include="Manifest\ManifestValidatorConverter.cs" />
+    <Compile Include="Manifest\ManifestWatcher.cs" />
     <Compile Include="Manifest\PackageManifest.cs" />
     <Compile Include="Manifest\ParameterEditorConverter.cs" />
     <Compile Include="Manifest\PreValueFieldConverter.cs" />
@@ -349,12 +351,14 @@
     <Compile Include="Models\MemberGroup.cs" />
     <Compile Include="Models\MemberTypePropertyProfileAccess.cs" />
     <Compile Include="Models\Notification.cs" />
+    <Compile Include="Models\PropertyTagBehavior.cs" />
     <Compile Include="Models\PublishedContent\IPublishedContentExtended.cs" />
     <Compile Include="Models\PublishedContent\PublishedPropertyBase.cs" />
-    <Compile Include="Models\PublishedContent\PublishedContentModelFactoryImpl.cs" />
+    <Compile Include="Models\PublishedContent\PublishedContentModelFactory.cs" />
     <Compile Include="Models\PublishedContent\IPublishedContentModelFactory.cs" />
     <Compile Include="Models\PublishedContent\PublishedContentModel.cs" />
     <Compile Include="Models\PublishedContent\PublishedContentModelFactoryResolver.cs" />
+    <Compile Include="Models\TagCacheStorageType.cs" />
     <Compile Include="Models\TaggableObjectTypes.cs" />
     <Compile Include="Models\TemplateNode.cs" />
     <Compile Include="Models\UmbracoEntityExtensions.cs" />
@@ -403,6 +407,7 @@
     <Compile Include="PropertyEditors\TagPropertyDefinition.cs" />
     <Compile Include="PropertyEditors\TagValueType.cs" />
     <Compile Include="PropertyEditors\ValueConverters\IntegerValueConverter.cs" />
+    <Compile Include="PropertyEditors\IPropertyValueConverterMeta.cs" />
     <Compile Include="PropertyEditors\ValueConverters\JsonValueConverter.cs" />
     <Compile Include="PropertyEditors\ValueConverters\MultipleTextStringValueConverter.cs" />
     <Compile Include="PropertyEditors\ValueConverters\MarkdownEditorValueConverter.cs" />
@@ -439,7 +444,7 @@
     <Compile Include="Models\Macro.cs" />
     <Compile Include="Models\PublishedContent\PublishedContentExtended.cs" />
     <Compile Include="Models\PublishedContent\PublishedContentModelAttribute.cs" />
-    <Compile Include="Models\PublishedContent\PublishedContentModelFactory.cs" />
+    <Compile Include="Models\PublishedContent\PublishedContentExtensionsForModels.cs" />
     <Compile Include="Models\MacroProperty.cs" />
     <Compile Include="Models\MacroPropertyCollection.cs" />
     <Compile Include="Models\MacroPropertyTypeBaseTypes.cs" />
@@ -1061,6 +1066,7 @@
     <Compile Include="Standalone\StandaloneCoreBootManager.cs" />
     <Compile Include="Strings\ContentBaseExtensions.cs" />
     <Compile Include="Strings\Diff.cs" />
+    <Compile Include="Sync\RefreshInstruction.cs" />
     <Compile Include="TopologicalSorter.cs" />
     <Compile Include="Strings\DefaultUrlSegmentProvider.cs" />
     <Compile Include="Strings\IUrlSegmentProvider.cs" />
@@ -1157,6 +1163,7 @@
     <Compile Include="Xml\XPathVariable.cs" />
   </ItemGroup>
   <ItemGroup>
+    <None Include="app.config" />
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>

src/Umbraco.Core/app.config

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.0.0" newVersion="4.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Web.WebPages" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-2.0.0.0" newVersion="2.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>

src/Umbraco.Core/packages.config

@@ -9,8 +9,8 @@
   <package id="Microsoft.AspNet.WebPages" version="2.0.30506.0" targetFramework="net40" />
   <package id="Microsoft.Net.Http" version="2.0.20710.0" targetFramework="net45" />
   <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net40" />
-  <package id="MiniProfiler" version="2.1.0" targetFramework="net40" />
-  <package id="Newtonsoft.Json" version="6.0.2" targetFramework="net45" />
+  <package id="MiniProfiler" version="2.1.0" targetFramework="net45" />
   <package id="MySql.Data" version="6.6.5" targetFramework="net40" />
+  <package id="Newtonsoft.Json" version="6.0.2" targetFramework="net45" />
   <package id="SqlServerCE" version="4.0.0.0" targetFramework="net40" />
 </packages>

src/Umbraco.Tests/AngularIntegration/JsInitializationTests.cs

@@ -26,27 +26,13 @@ namespace Umbraco.Tests.AngularIntegration
         {
             var result = JsInitialization.ParseMain(new[] {"[World]", "Hello" });
 
-            Assert.AreEqual(@"
-yepnope({
-    load: [
-         'lib/jquery/jquery-2.0.3.min.js',
-         'lib/angular/1.1.5/angular.min.js',
-         'lib/underscore/underscore.js',
-    ],
-    complete: function () {
-        yepnope({
-            load: [World],
-            complete: function () {
+            Assert.AreEqual(@"LazyLoad.js([World], function () {
+    //we need to set the legacy UmbClientMgr path
+    UmbClientMgr.setUmbracoPath('Hello');
 
-                //we need to set the legacy UmbClientMgr path
-                UmbClientMgr.setUmbracoPath('Hello');
-
-                jQuery(document).ready(function () {
-                    angular.bootstrap(document, ['umbraco']);
-                });
-            }
-        });
-    }
+    jQuery(document).ready(function () {
+        angular.bootstrap(document, ['umbraco']);
+    });
 });", result);
         }
     }

src/Umbraco.Tests/App.config

@@ -1,9 +1,9 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
   <configSections>
 
     <sectionGroup name="umbracoConfiguration">    
-      <section name="FileSystemProviders" type="Umbraco.Core.Configuration.FileSystemProvidersSection, Umbraco.Core" requirePermission="false"/>
+      <section name="FileSystemProviders" type="Umbraco.Core.Configuration.FileSystemProvidersSection, Umbraco.Core" requirePermission="false" />
     </sectionGroup>
     
   </configSections>
@@ -12,69 +12,69 @@
     <FileSystemProviders>
       <Provider alias="media" type="Umbraco.Core.IO.PhysicalFileSystem, Umbraco.Core">
         <Parameters>
-          <add key="rootPath" value="\Media\"/>
-          <add key="rootUrl" value="/Media/"/>
+          <add key="rootPath" value="\Media\" />
+          <add key="rootUrl" value="/Media/" />
         </Parameters>
       </Provider>
       <!-- Macros -->
       <Provider alias="macros" type="Umbraco.Core.IO.PhysicalFileSystem, Umbraco.Core">
         <Parameters>
-          <add key="rootPath" value="\App_Data\Macros"/>
-          <add key="rootUrl" value="/Macros/"/>
+          <add key="rootPath" value="\App_Data\Macros" />
+          <add key="rootUrl" value="/Macros/" />
         </Parameters>
       </Provider>
       <!-- Scripts -->
       <Provider alias="scripts" type="Umbraco.Core.IO.PhysicalFileSystem, Umbraco.Core">
         <Parameters>
-          <add key="rootPath" value="\scripts\"/>
-          <add key="rootUrl" value="/scripts/"/>
+          <add key="rootPath" value="\scripts\" />
+          <add key="rootUrl" value="/scripts/" />
         </Parameters>
       </Provider>
       <!-- Stylesheets -->
       <Provider alias="stylesheets" type="Umbraco.Core.IO.PhysicalFileSystem, Umbraco.Core">
         <Parameters>
-          <add key="rootPath" value="\css\"/>
-          <add key="rootUrl" value="/css/"/>
+          <add key="rootPath" value="\css\" />
+          <add key="rootUrl" value="/css/" />
         </Parameters>
       </Provider>
       <!-- Templates -->
       <Provider alias="masterpages" type="Umbraco.Core.IO.PhysicalFileSystem, Umbraco.Core">
         <Parameters>
-          <add key="rootPath" value="\masterpages\"/>
-          <add key="rootUrl" value="/masterpages/"/>
+          <add key="rootPath" value="\masterpages\" />
+          <add key="rootUrl" value="/masterpages/" />
         </Parameters>
       </Provider>
       <Provider alias="views" type="Umbraco.Core.IO.PhysicalFileSystem, Umbraco.Core">
         <Parameters>
-          <add key="rootPath" value="\views\"/>
-          <add key="rootUrl" value="/views/"/>
+          <add key="rootPath" value="\views\" />
+          <add key="rootUrl" value="/views/" />
         </Parameters>
       </Provider>
     </FileSystemProviders>
   </umbracoConfiguration>
   
   <appSettings>
-    <add key="umbracoConfigurationStatus" value="6.0.0"/>
-    <add key="umbracoReservedUrls" value="~/config/splashes/booting.aspx,~/install/default.aspx,~/config/splashes/noNodes.aspx,~/VSEnterpriseHelper.axd"/>
-    <add key="umbracoReservedPaths" value="~/umbraco,~/install/"/>
-    <add key="umbracoPath" value="~/umbraco"/>
-    <add key="umbracoHideTopLevelNodeFromPath" value="true"/>
-    <add key="umbracoUseDirectoryUrls" value="false"/>
-    <add key="umbracoTimeOutInMinutes" value="20"/>
-    <add key="umbracoDefaultUILanguage" value="en"/>
-    <add key="umbracoUseSSL" value="false"/>
+    <add key="umbracoConfigurationStatus" value="6.0.0" />
+    <add key="umbracoReservedUrls" value="~/config/splashes/booting.aspx,~/install/default.aspx,~/config/splashes/noNodes.aspx,~/VSEnterpriseHelper.axd" />
+    <add key="umbracoReservedPaths" value="~/umbraco,~/install/" />
+    <add key="umbracoPath" value="~/umbraco" />
+    <add key="umbracoHideTopLevelNodeFromPath" value="true" />
+    <add key="umbracoUseDirectoryUrls" value="false" />
+    <add key="umbracoTimeOutInMinutes" value="20" />
+    <add key="umbracoDefaultUILanguage" value="en" />
+    <add key="umbracoUseSSL" value="false" />
   </appSettings>
   
   <connectionStrings>
-    <add name="umbracoDbDSN" connectionString="Datasource=|DataDirectory|UmbracoPetaPocoTests.sdf;Flush Interval=1;" providerName="System.Data.SqlServerCe.4.0"/>
+    <add name="umbracoDbDSN" connectionString="Datasource=|DataDirectory|UmbracoPetaPocoTests.sdf;Flush Interval=1;" providerName="System.Data.SqlServerCe.4.0" />
   </connectionStrings>
 
   <system.data>
     <DbProviderFactories>
       <remove invariant="System.Data.SqlServerCe.4.0" />
-      <add name="Microsoft SQL Server Compact Data Provider 4.0" invariant="System.Data.SqlServerCe.4.0" description=".NET Framework Data Provider for Microsoft SQL Server Compact" type="System.Data.SqlServerCe.SqlCeProviderFactory, System.Data.SqlServerCe, Version=4.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91"/>
+      <add name="Microsoft SQL Server Compact Data Provider 4.0" invariant="System.Data.SqlServerCe.4.0" description=".NET Framework Data Provider for Microsoft SQL Server Compact" type="System.Data.SqlServerCe.SqlCeProviderFactory, System.Data.SqlServerCe, Version=4.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91" />
       <remove invariant="MySql.Data.MySqlClient" />
-      <add name="MySQL Data Provider" invariant="MySql.Data.MySqlClient" description=".Net Framework Data Provider for MySQL" type="MySql.Data.MySqlClient.MySqlClientFactory, MySql.Data, Version=6.6.4.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d"/>
+      <add name="MySQL Data Provider" invariant="MySql.Data.MySqlClient" description=".Net Framework Data Provider for MySQL" type="MySql.Data.MySqlClient.MySqlClientFactory, MySql.Data, Version=6.6.4.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d" />
     </DbProviderFactories>
   </system.data>
 
@@ -85,13 +85,13 @@
     <!-- Sitemap provider-->
     <siteMap defaultProvider="UmbracoSiteMapProvider" enabled="true">
       <providers>
-        <clear/>
-        <add name="UmbracoSiteMapProvider" type="umbraco.presentation.nodeFactory.UmbracoSiteMapProvider" defaultDescriptionAlias="description" securityTrimmingEnabled="true"/>
+        <clear />
+        <add name="UmbracoSiteMapProvider" type="umbraco.presentation.nodeFactory.UmbracoSiteMapProvider" defaultDescriptionAlias="description" securityTrimmingEnabled="true" />
       </providers>
     </siteMap>
   </system.web>
 
-<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5"/></startup>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" /></startup>
   <runtime>
 
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
@@ -128,6 +128,14 @@
         
       </dependentAssembly>
       
+      <dependentAssembly>
+
+        <assemblyIdentity name="MiniProfiler" publicKeyToken="b44f9351044011a3" culture="neutral" />
+
+        <bindingRedirect oldVersion="0.0.0.0-2.1.0.0" newVersion="2.1.0.0" />
+
+      </dependentAssembly>
+
     </assemblyBinding>
 
   </runtime>

src/Umbraco.Tests/Models/ContentTypeTests.cs

@@ -12,6 +12,8 @@ namespace Umbraco.Tests.Models
     [TestFixture]
     public class ContentTypeTests : BaseUmbracoConfigurationTest
     {
+       
+
         [Test]
         public void Can_Deep_Clone_Content_Type_Sort()
         {
@@ -150,6 +152,7 @@ namespace Umbraco.Tests.Models
             }
             Assert.AreNotSame(clone.PropertyTypes, contentType.PropertyTypes);
             Assert.AreEqual(clone.PropertyTypes.Count(), contentType.PropertyTypes.Count());
+            Assert.AreEqual(0, ((ContentTypeBase)clone).NonGroupedPropertyTypes.Count());
             for (var index = 0; index < contentType.PropertyTypes.Count(); index++)
             {
                 Assert.AreNotSame(clone.PropertyTypes.ElementAt(index), contentType.PropertyTypes.ElementAt(index));

src/Umbraco.Tests/Models/MacroTests.cs

@@ -1,3 +1,4 @@
+using System.Linq;
 using NUnit.Framework;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;
@@ -19,6 +20,7 @@ namespace Umbraco.Tests.Models
         public void Can_Deep_Clone()
         {
             var macro = new Macro(1, true, 3, "test", "Test", "blah", "blah", "xslt", false, true, true, "script");
+            macro.Properties.Add(new MacroProperty(6, "rewq", "REWQ", 1, "asdfasdf"));
 
             var clone = (Macro)macro.DeepClone();
 
@@ -26,6 +28,14 @@ namespace Umbraco.Tests.Models
             Assert.AreEqual(clone, macro);
             Assert.AreEqual(clone.Id, macro.Id);
 
+            Assert.AreEqual(clone.Properties.Count, macro.Properties.Count);
+
+            for (int i = 0; i < clone.Properties.Count; i++)
+            {
+                Assert.AreEqual(clone.Properties[i], macro.Properties[i]);
+                Assert.AreNotSame(clone.Properties[i], macro.Properties[i]);
+            }
+
             Assert.AreNotSame(clone.Properties, macro.Properties);
             Assert.AreNotSame(clone.AddedProperties, macro.AddedProperties);
             Assert.AreNotSame(clone.RemovedProperties, macro.RemovedProperties);
@@ -44,6 +54,9 @@ namespace Umbraco.Tests.Models
             Assert.IsFalse(asDirty.IsPropertyDirty("Properties"));
             clone.Properties.Add(new MacroProperty(3, "asdf", "SDF", 3, "asdfasdf"));
             Assert.IsTrue(asDirty.IsPropertyDirty("Properties"));
+            Assert.AreEqual(1, clone.AddedProperties.Count());
+            clone.Properties.Remove("rewq");
+            Assert.AreEqual(1, clone.RemovedProperties.Count());
 
         }
 

src/Umbraco.Tests/Models/PreValueCollectionTests.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Umbraco.Core.Models;
+
+namespace Umbraco.Tests.Models
+{
+    [TestFixture]
+    public class PreValueCollectionTests
+    {
+        [Test]
+        public void Can_Deep_Clone()
+        {
+            var d = new PreValueCollection(new Dictionary<string, PreValue>
+            {
+                {"blah1", new PreValue(1, "test1", 1)},
+                {"blah2", new PreValue(2, "test1", 3)},
+                {"blah3", new PreValue(3, "test1", 2)}
+            });
+
+            var a = new PreValueCollection(new[]
+            {
+                new PreValue(1, "test1", 1),
+                new PreValue(2, "test1", 3),
+                new PreValue(3, "test1", 2)
+            });
+
+            var clone1 = (PreValueCollection)d.DeepClone();
+            var clone2 = (PreValueCollection)a.DeepClone();
+
+            Action<PreValueCollection, PreValueCollection> assert = (orig, clone) =>
+            {
+                Assert.AreNotSame(orig, clone);
+                var oDic = orig.FormatAsDictionary();
+                var cDic = clone.FormatAsDictionary();
+                Assert.AreEqual(oDic.Keys.Count(), cDic.Keys.Count());
+                foreach (var k in oDic.Keys)
+                {
+                    Assert.AreNotSame(oDic[k], cDic[k]);
+                    Assert.AreEqual(oDic[k].Id, cDic[k].Id);
+                    Assert.AreEqual(oDic[k].SortOrder, cDic[k].SortOrder);
+                    Assert.AreEqual(oDic[k].Value, cDic[k].Value);
+                }
+            };
+
+            assert(d, clone1);
+            assert(a, clone2);
+        }
+    }
+}

src/Umbraco.Tests/Models/PropertyGroupTests.cs

@@ -2,11 +2,12 @@ using System;
 using NUnit.Framework;
 using Umbraco.Core.Models;
 using Umbraco.Core.Serialization;
+using Umbraco.Tests.TestHelpers;
 
 namespace Umbraco.Tests.Models
 {
     [TestFixture]
-    public class PropertyGroupTests
+    public class PropertyGroupTests : BaseUmbracoConfigurationTest
     {
         [Test]
         public void Can_Deep_Clone()
@@ -37,7 +38,7 @@ namespace Umbraco.Tests.Models
                         Alias = "test2",
                         CreateDate = DateTime.Now,
                         DataTypeDefinitionId = 6,
-                        DataTypeId = Guid.NewGuid(),
+                        PropertyEditorAlias = "propTest",
                         Description = "testing2",
                         Key = Guid.NewGuid(),
                         Mandatory = true,
@@ -118,7 +119,7 @@ namespace Umbraco.Tests.Models
                         Alias = "test2",
                         CreateDate = DateTime.Now,
                         DataTypeDefinitionId = 6,
-                        DataTypeId = Guid.NewGuid(),
+                        PropertyEditorAlias = "propTest",
                         Description = "testing2",
                         Key = Guid.NewGuid(),
                         Mandatory = true,

src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs

@@ -364,7 +364,58 @@ namespace Umbraco.Tests.Persistence.Repositories
             }
         }
 
+        [Test]
+        public void Can_Update_Property_For_Macro()
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current))
+            {
+                var macro = repository.Get(1);
+                macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test"));
+                repository.AddOrUpdate(macro);
+                unitOfWork.Commit();
 
+                //Act 
+                macro = repository.Get(1);
+                macro.Properties["new1"].Name = "this is a new name";
+                repository.AddOrUpdate(macro);
+                unitOfWork.Commit();
+
+
+                // Assert
+                var result = repository.Get(1);                
+                Assert.AreEqual("new1", result.Properties.First().Alias);
+                Assert.AreEqual("this is a new name", result.Properties.First().Name);
+
+            }
+        }
+
+        [Test]
+        public void Can_Update_Macro_Property_Alias()
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current))
+            {
+                var macro = repository.Get(1);
+                macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test"));
+                repository.AddOrUpdate(macro);
+                unitOfWork.Commit();
+
+                //Act 
+                macro = repository.Get(1);
+                macro.Properties.UpdateProperty("new1", newAlias: "newAlias");
+                repository.AddOrUpdate(macro);
+                unitOfWork.Commit();
+                
+                // Assert
+                var result = repository.Get(1);
+                Assert.AreEqual("newAlias", result.Properties.First().Alias);
+            }
+        }
 
         [TearDown]
         public override void TearDown()

src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs

@@ -3,6 +3,7 @@ using System.IO;
 using System.Linq;
 using System.Text;
 using NUnit.Framework;
+using Umbraco.Core;
 using Umbraco.Core.IO;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence;
@@ -10,6 +11,7 @@ using Umbraco.Core.Persistence.Caching;
 using Umbraco.Core.Persistence.Repositories;
 using Umbraco.Core.Persistence.UnitOfWork;
 using Umbraco.Tests.TestHelpers;
+using Umbraco.Tests.TestHelpers.Entities;
 
 namespace Umbraco.Tests.Persistence.Repositories
 {
@@ -37,10 +39,13 @@ namespace Umbraco.Tests.Persistence.Repositories
             var unitOfWork = provider.GetUnitOfWork();
 
             // Act
-            var repository = RepositoryResolver.Current.ResolveByType<ITemplateRepository>(unitOfWork);
+            using (var repository = RepositoryResolver.Current.ResolveByType<ITemplateRepository>(unitOfWork))
+            {
+
+                // Assert
+                Assert.That(repository, Is.Not.Null);    
+            }
 
-            // Assert
-            Assert.That(repository, Is.Not.Null);
         }
 
         [Test]
@@ -51,10 +56,13 @@ namespace Umbraco.Tests.Persistence.Repositories
             var unitOfWork = provider.GetUnitOfWork();
 
             // Act
-            var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem);
+            using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem))
+            {
+
+                // Assert
+                Assert.That(repository, Is.Not.Null);    
+            }
 
-            // Assert
-            Assert.That(repository, Is.Not.Null);
         }
 
         [Test]
@@ -63,16 +71,18 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new PetaPocoUnitOfWorkProvider();
             var unitOfWork = provider.GetUnitOfWork();
-            var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem);
+            using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem))
+            {
+                // Act
+                var template = new Template("test-add-masterpage.master", "test", "test") { Content = @"<%@ Master Language=""C#"" %>" };
+                repository.AddOrUpdate(template);
+                unitOfWork.Commit();
 
-            // Act
-            var template = new Template("test-add-masterpage.master", "test", "test") { Content = @"<%@ Master Language=""C#"" %>" };
-            repository.AddOrUpdate(template);
-            unitOfWork.Commit();
-
-            //Assert
-            Assert.That(repository.Get("test"), Is.Not.Null);
-            Assert.That(_masterPageFileSystem.FileExists("test.master"), Is.True);
+                //Assert
+                Assert.That(repository.Get("test"), Is.Not.Null);
+                Assert.That(_masterPageFileSystem.FileExists("test.master"), Is.True);    
+            }
+            
         }
 
         [Test]
@@ -81,22 +91,25 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new PetaPocoUnitOfWorkProvider();
             var unitOfWork = provider.GetUnitOfWork();
-            var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem);
+            using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem))
+            {
+                // Act
+                var template = new Template("test-updated-masterpage.master", "test", "test") { Content = @"<%@ Master Language=""C#"" %>" };
+                repository.AddOrUpdate(template);
+                unitOfWork.Commit();
 
-            // Act
-            var template = new Template("test-updated-masterpage.master", "test", "test") { Content = @"<%@ Master Language=""C#"" %>" };
-            repository.AddOrUpdate(template);
-            unitOfWork.Commit();
+                template.Content = @"<%@ Master Language=""VB"" %>";
+                repository.AddOrUpdate(template);
+                unitOfWork.Commit();
 
-            template.Content = @"<%@ Master Language=""VB"" %>";
-            repository.AddOrUpdate(template);
-            unitOfWork.Commit();
+                var updated = repository.Get("test");
 
-            var updated = repository.Get("test");
+                // Assert
+                Assert.That(_masterPageFileSystem.FileExists("test.master"), Is.True);
+                Assert.That(updated.Content, Is.EqualTo(@"<%@ Master Language=""VB"" %>"));    
+            }
 
-            // Assert
-            Assert.That(_masterPageFileSystem.FileExists("test.master"), Is.True);
-            Assert.That(updated.Content, Is.EqualTo(@"<%@ Master Language=""VB"" %>"));
+            
         }
 
         [Test]
@@ -105,19 +118,64 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new PetaPocoUnitOfWorkProvider();
             var unitOfWork = provider.GetUnitOfWork();
-            var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem);
+            using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem))
+            {
+                var template = new Template("test-add-masterpage.master", "test", "test") { Content = @"<%@ Master Language=""C#"" %>" };
+                repository.AddOrUpdate(template);
+                unitOfWork.Commit();
 
-            var template = new Template("test-add-masterpage.master", "test", "test") { Content = @"<%@ Master Language=""C#"" %>" };
-            repository.AddOrUpdate(template);
-            unitOfWork.Commit();
+                // Act
+                var templates = repository.Get("test");
+                repository.Delete(templates);
+                unitOfWork.Commit();
 
-            // Act
-            var templates = repository.Get("test");
-            repository.Delete(templates);
-            unitOfWork.Commit();
+                // Assert
+                Assert.IsNull(repository.Get("test"));
+            }
 
-            // Assert
-            Assert.IsNull(repository.Get("test"));
+           
+        }
+
+        [Test]
+        public void Can_Perform_Delete_When_Assigned_To_Doc()
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+
+            var templateRepository = new TemplateRepository(unitOfWork, NullCacheProvider.Current);
+            var tagRepository = new TagsRepository(unitOfWork, NullCacheProvider.Current);
+            var contentTypeRepository = new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, templateRepository);
+            var contentRepo = new ContentRepository(unitOfWork, NullCacheProvider.Current, contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper());
+
+            using (contentRepo)
+            {
+                var contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage2", "Textpage");
+                var textpage = MockedContent.CreateSimpleContent(contentType);
+                contentTypeRepository.AddOrUpdate(contentType);
+                contentRepo.AddOrUpdate(textpage);
+                unitOfWork.Commit();
+
+                using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem))
+                {
+                    var template = new Template("test-add-masterpage.master", "test", "test") { Content = @"<%@ Master Language=""C#"" %>" };
+                    repository.AddOrUpdate(template);
+                    unitOfWork.Commit();
+
+                    textpage.Template = template;
+                    contentRepo.AddOrUpdate(textpage);
+                    unitOfWork.Commit();
+
+                    // Act
+                    var templates = repository.Get("test");
+                    repository.Delete(templates);
+                    unitOfWork.Commit();
+
+                    // Assert
+                    Assert.IsNull(repository.Get("test"));
+                }
+            }
+            
         }
 
         [Test]
@@ -126,27 +184,30 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new PetaPocoUnitOfWorkProvider();
             var unitOfWork = provider.GetUnitOfWork();
-            var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem);
+            using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem))
+            {
+                var parent = new Template("test-parent-masterpage.master", "parent", "parent") { Content = @"<%@ Master Language=""C#"" %>" };
+                var child = new Template("test-child-masterpage.master", "child", "child") { Content = @"<%@ Master Language=""C#"" %>" };
+                var baby = new Template("test-baby-masterpage.master", "baby", "baby") { Content = @"<%@ Master Language=""C#"" %>" };
+                child.MasterTemplateAlias = parent.Alias;
+                child.MasterTemplateId = new Lazy<int>(() => parent.Id);
+                baby.MasterTemplateAlias = child.Alias;
+                baby.MasterTemplateId = new Lazy<int>(() => child.Id);
+                repository.AddOrUpdate(parent);
+                repository.AddOrUpdate(child);
+                repository.AddOrUpdate(baby);
+                unitOfWork.Commit();
 
-            var parent = new Template("test-parent-masterpage.master", "parent", "parent") { Content = @"<%@ Master Language=""C#"" %>" };
-            var child = new Template("test-child-masterpage.master", "child", "child") { Content = @"<%@ Master Language=""C#"" %>" };
-            var baby = new Template("test-baby-masterpage.master", "baby", "baby") { Content = @"<%@ Master Language=""C#"" %>" };            
-            child.MasterTemplateAlias = parent.Alias;
-            child.MasterTemplateId = new Lazy<int>(() => parent.Id);
-            baby.MasterTemplateAlias = child.Alias;
-            baby.MasterTemplateId = new Lazy<int>(() => child.Id);
-            repository.AddOrUpdate(parent);
-            repository.AddOrUpdate(child);
-            repository.AddOrUpdate(baby);
-            unitOfWork.Commit();
+                // Act
+                var templates = repository.Get("parent");
+                repository.Delete(templates);
+                unitOfWork.Commit();
 
-            // Act
-            var templates = repository.Get("parent");
-            repository.Delete(templates);
-            unitOfWork.Commit();
+                // Assert
+                Assert.IsNull(repository.Get("test"));
+            }
 
-            // Assert
-            Assert.IsNull(repository.Get("test"));
+            
         }
 
         [Test]
@@ -155,66 +216,69 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new PetaPocoUnitOfWorkProvider();
             var unitOfWork = provider.GetUnitOfWork();
-            var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem);
+            using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem))
+            {
+                var parent = new Template("test-parent-masterpage.master", "parent", "parent") { Content = @"<%@ Master Language=""C#"" %>" };
+
+                var child1 = new Template("test-child1-masterpage.master", "child1", "child1") { Content = @"<%@ Master Language=""C#"" %>" };
+                var toddler1 = new Template("test-toddler1-masterpage.master", "toddler1", "toddler1") { Content = @"<%@ Master Language=""C#"" %>" };
+                var toddler2 = new Template("test-toddler2-masterpage.master", "toddler2", "toddler2") { Content = @"<%@ Master Language=""C#"" %>" };
+                var baby1 = new Template("test-baby1-masterpage.master", "baby1", "baby1") { Content = @"<%@ Master Language=""C#"" %>" };
+
+                var child2 = new Template("test-child2-masterpage.master", "child2", "child2") { Content = @"<%@ Master Language=""C#"" %>" };
+                var toddler3 = new Template("test-toddler3-masterpage.master", "toddler3", "toddler3") { Content = @"<%@ Master Language=""C#"" %>" };
+                var toddler4 = new Template("test-toddler4-masterpage.master", "toddler4", "toddler4") { Content = @"<%@ Master Language=""C#"" %>" };
+                var baby2 = new Template("test-baby2-masterpage.master", "baby2", "baby2") { Content = @"<%@ Master Language=""C#"" %>" };
+
+
+                child1.MasterTemplateAlias = parent.Alias;
+                child1.MasterTemplateId = new Lazy<int>(() => parent.Id);
+                child2.MasterTemplateAlias = parent.Alias;
+                child2.MasterTemplateId = new Lazy<int>(() => parent.Id);
+
+                toddler1.MasterTemplateAlias = child1.Alias;
+                toddler1.MasterTemplateId = new Lazy<int>(() => child1.Id);
+                toddler2.MasterTemplateAlias = child1.Alias;
+                toddler2.MasterTemplateId = new Lazy<int>(() => child1.Id);
+
+                toddler3.MasterTemplateAlias = child2.Alias;
+                toddler3.MasterTemplateId = new Lazy<int>(() => child2.Id);
+                toddler4.MasterTemplateAlias = child2.Alias;
+                toddler4.MasterTemplateId = new Lazy<int>(() => child2.Id);
+
+                baby1.MasterTemplateAlias = toddler2.Alias;
+                baby1.MasterTemplateId = new Lazy<int>(() => toddler2.Id);
+
+                baby2.MasterTemplateAlias = toddler4.Alias;
+                baby2.MasterTemplateId = new Lazy<int>(() => toddler4.Id);
+
+                repository.AddOrUpdate(parent);
+                repository.AddOrUpdate(child1);
+                repository.AddOrUpdate(child2);
+                repository.AddOrUpdate(toddler1);
+                repository.AddOrUpdate(toddler2);
+                repository.AddOrUpdate(toddler3);
+                repository.AddOrUpdate(toddler4);
+                repository.AddOrUpdate(baby1);
+                repository.AddOrUpdate(baby2);
+                unitOfWork.Commit();
+
+                // Act
+                var rootNode = repository.GetTemplateNode("parent");
+
+                // Assert
+                Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "parent"));
+                Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "child1"));
+                Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "child2"));
+                Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "toddler1"));
+                Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "toddler2"));
+                Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "toddler3"));
+                Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "toddler4"));
+                Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "baby1"));
+                Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "baby2"));
+            }
 
-            var parent = new Template("test-parent-masterpage.master", "parent", "parent") { Content = @"<%@ Master Language=""C#"" %>" };
             
-            var child1 = new Template("test-child1-masterpage.master", "child1", "child1") { Content = @"<%@ Master Language=""C#"" %>" };
-            var toddler1 = new Template("test-toddler1-masterpage.master", "toddler1", "toddler1") { Content = @"<%@ Master Language=""C#"" %>" };
-            var toddler2 = new Template("test-toddler2-masterpage.master", "toddler2", "toddler2") { Content = @"<%@ Master Language=""C#"" %>" };
-            var baby1 = new Template("test-baby1-masterpage.master", "baby1", "baby1") { Content = @"<%@ Master Language=""C#"" %>" };
-
-            var child2 = new Template("test-child2-masterpage.master", "child2", "child2") { Content = @"<%@ Master Language=""C#"" %>" };
-            var toddler3 = new Template("test-toddler3-masterpage.master", "toddler3", "toddler3") { Content = @"<%@ Master Language=""C#"" %>" };
-            var toddler4 = new Template("test-toddler4-masterpage.master", "toddler4", "toddler4") { Content = @"<%@ Master Language=""C#"" %>" };
-            var baby2 = new Template("test-baby2-masterpage.master", "baby2", "baby2") { Content = @"<%@ Master Language=""C#"" %>" };
-            
-            
-            child1.MasterTemplateAlias = parent.Alias;
-            child1.MasterTemplateId = new Lazy<int>(() => parent.Id);
-            child2.MasterTemplateAlias = parent.Alias;
-            child2.MasterTemplateId = new Lazy<int>(() => parent.Id);
-
-            toddler1.MasterTemplateAlias = child1.Alias;
-            toddler1.MasterTemplateId = new Lazy<int>(() => child1.Id);
-            toddler2.MasterTemplateAlias = child1.Alias;
-            toddler2.MasterTemplateId = new Lazy<int>(() => child1.Id);
-
-            toddler3.MasterTemplateAlias = child2.Alias;
-            toddler3.MasterTemplateId = new Lazy<int>(() => child2.Id);
-            toddler4.MasterTemplateAlias = child2.Alias;
-            toddler4.MasterTemplateId = new Lazy<int>(() => child2.Id);
-
-            baby1.MasterTemplateAlias = toddler2.Alias;
-            baby1.MasterTemplateId = new Lazy<int>(() => toddler2.Id);
-
-            baby2.MasterTemplateAlias = toddler4.Alias;
-            baby2.MasterTemplateId = new Lazy<int>(() => toddler4.Id);
-
-            repository.AddOrUpdate(parent);
-            repository.AddOrUpdate(child1);
-            repository.AddOrUpdate(child2);
-            repository.AddOrUpdate(toddler1);
-            repository.AddOrUpdate(toddler2);
-            repository.AddOrUpdate(toddler3);
-            repository.AddOrUpdate(toddler4);
-            repository.AddOrUpdate(baby1);
-            repository.AddOrUpdate(baby2);
-            unitOfWork.Commit();
-
-            // Act
-            var rootNode = repository.GetTemplateNode("parent");
-            
-            // Assert
-            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "parent"));
-            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "child1"));
-            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "child2"));
-            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "toddler1"));
-            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "toddler2"));
-            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "toddler3"));
-            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "toddler4"));
-            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "baby1"));
-            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "baby2"));
         }
 
         //[Test]

src/Umbraco.Tests/PublishedContent/DynamicPublishedContentTests.cs

@@ -1,3 +1,4 @@
+using System;
 using System.IO;
 using System.Linq;
 using NUnit.Framework;
@@ -31,7 +32,50 @@ namespace Umbraco.Tests.PublishedContent
 			return GetNode(id).AsDynamic();
 		}
 
-		[Test]
+        [Test]
+        public void FirstChild()
+        {
+            var content = GetDynamicNode(1173);
+
+            var x = content.FirstChild();
+            Assert.IsNotNull(x);
+            Assert.IsInstanceOf<DynamicPublishedContent>(x);
+            Assert.AreEqual(1174, x.Id);
+
+            x = content.FirstChild("CustomDocument");
+            Assert.IsNotNull(x);
+            Assert.IsInstanceOf<DynamicPublishedContent>(x);
+            Assert.AreEqual(1177, x.Id);
+        }
+
+        [Test]
+        public void Children()
+        {
+            var content = GetDynamicNode(1173);
+
+            var l = content.Children;
+            Assert.AreEqual(4, l.Count());
+
+            // works - but not by calling the extension method
+            // because the binder will in fact re-route to the property first
+            l = content.Children();
+            Assert.AreEqual(4, l.Count());
+        }
+
+        [Test]
+        public void ChildrenOfType()
+        {
+            var content = GetDynamicNode(1173);
+
+            var l = content.Children;
+            Assert.AreEqual(4, l.Count());
+
+            // fails - because it fails to find extension methods?
+            l = content.Children("CustomDocument");
+            Assert.AreEqual(2, l.Count());
+        }
+
+        [Test]
 		public void Custom_Extension_Methods()
 		{
 			var asDynamic = GetDynamicNode(1173);

src/Umbraco.Tests/PublishedContent/PublishedContentMoreTests.cs

@@ -44,8 +44,9 @@ namespace Umbraco.Tests.PublishedContent
         {
             PropertyValueConvertersResolver.Current =
                 new PropertyValueConvertersResolver();
+            var types = PluginManager.Current.ResolveTypes<PublishedContentModel>();
             PublishedContentModelFactoryResolver.Current =
-                new PublishedContentModelFactoryResolver(new PublishedContentModelFactoryImpl());
+                new PublishedContentModelFactoryResolver(new PublishedContentModelFactory(types));
 
             base.FreezeResolution();
         }

src/Umbraco.Tests/PublishedContent/PublishedContentTestElements.cs

@@ -32,7 +32,7 @@ namespace Umbraco.Tests.PublishedContent
 
         public void Add(SolidPublishedContent content)
         {
-            _content[content.Id] = PublishedContentModelFactory.CreateModel(content);
+            _content[content.Id] = content.CreateModel();
         }
 
         public void Clear()

src/Umbraco.Tests/PublishedContent/PublishedContentTests.cs

@@ -63,8 +63,9 @@ namespace Umbraco.Tests.PublishedContent
 
 	    protected override void FreezeResolution()
 	    {
+            var types = PluginManager.Current.ResolveTypes<PublishedContentModel>();
             PublishedContentModelFactoryResolver.Current = new PublishedContentModelFactoryResolver(
-                new PublishedContentModelFactoryImpl());
+                new PublishedContentModelFactory(types));
 	        base.FreezeResolution();
 	    }
 
@@ -221,7 +222,7 @@ namespace Umbraco.Tests.PublishedContent
             var doc = GetNode(1173);
 
             var items = doc.Children
-                .Select(PublishedContentModelFactory.CreateModel) // linq, returns IEnumerable<IPublishedContent>
+                .Select(x => x.CreateModel()) // linq, returns IEnumerable<IPublishedContent>
 
                 // only way around this is to make sure every IEnumerable<T> extension
                 // explicitely returns a PublishedContentSet, not an IEnumerable<T>

src/Umbraco.Tests/Services/ContentTypeServiceTests.cs

@@ -1,7 +1,7 @@
+using NUnit.Framework;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Rdbms;
@@ -11,30 +11,30 @@ using Umbraco.Tests.TestHelpers.Entities;
 namespace Umbraco.Tests.Services
 {
     [DatabaseTestBehavior(DatabaseBehavior.NewDbFileAndSchemaPerTest)]
-	[TestFixture, RequiresSTA]
-	public class ContentTypeServiceTests : BaseServiceTest
-	{
-		[SetUp]
-		public override void Initialize()
-		{
-			base.Initialize();
-		}
+    [TestFixture, RequiresSTA]
+    public class ContentTypeServiceTests : BaseServiceTest
+    {
+        [SetUp]
+        public override void Initialize()
+        {
+            base.Initialize();
+        }
 
-		[TearDown]
-		public override void TearDown()
-		{
-			base.TearDown();
-		}
+        [TearDown]
+        public override void TearDown()
+        {
+            base.TearDown();
+        }
 
-	    [Test]
-	    public void Deleting_PropertyType_Removes_The_Property_From_Content()
-	    {
+        [Test]
+        public void Deleting_PropertyType_Removes_The_Property_From_Content()
+        {
             IContentType contentType1 = MockedContentTypes.CreateTextpageContentType("test1", "Test1");
             ServiceContext.ContentTypeService.Save(contentType1);
-	        IContent contentItem = MockedContent.CreateTextpageContent(contentType1, "Testing", -1);
-	        ServiceContext.ContentService.SaveAndPublish(contentItem);
-	        var initProps = contentItem.Properties.Count;
-	        var initPropTypes = contentItem.PropertyTypes.Count();
+            IContent contentItem = MockedContent.CreateTextpageContent(contentType1, "Testing", -1);
+            ServiceContext.ContentService.SaveAndPublishWithStatus(contentItem);
+            var initProps = contentItem.Properties.Count;
+            var initPropTypes = contentItem.PropertyTypes.Count();
 
             //remove a property
             contentType1.RemovePropertyType(contentType1.PropertyTypes.First().Alias);
@@ -44,30 +44,31 @@ namespace Umbraco.Tests.Services
             contentItem = ServiceContext.ContentService.GetById(contentItem.Id);
 
             Assert.AreEqual(initPropTypes - 1, contentItem.PropertyTypes.Count());
-            Assert.AreEqual(initProps -1, contentItem.Properties.Count);
-	    }
+            Assert.AreEqual(initProps - 1, contentItem.Properties.Count);
+        }
 
-	    [Test]
-	    public void Rebuild_Content_Xml_On_Alias_Change()
+        [Test]
+        public void Rebuild_Content_Xml_On_Alias_Change()
         {
             var contentType1 = MockedContentTypes.CreateTextpageContentType("test1", "Test1");
             var contentType2 = MockedContentTypes.CreateTextpageContentType("test2", "Test2");
             ServiceContext.ContentTypeService.Save(contentType1);
             ServiceContext.ContentTypeService.Save(contentType2);
-	        var contentItems1 = MockedContent.CreateTextpageContent(contentType1, -1, 10).ToArray();
-            contentItems1.ForEach(x => ServiceContext.ContentService.SaveAndPublish(x));
+            var contentItems1 = MockedContent.CreateTextpageContent(contentType1, -1, 10).ToArray();
+            contentItems1.ForEach(x => ServiceContext.ContentService.SaveAndPublishWithStatus(x));
             var contentItems2 = MockedContent.CreateTextpageContent(contentType2, -1, 5).ToArray();
-            contentItems2.ForEach(x => ServiceContext.ContentService.SaveAndPublish(x));
+            contentItems2.ForEach(x => ServiceContext.ContentService.SaveAndPublishWithStatus(x));
             //only update the contentType1 alias which will force an xml rebuild for all content of that type
-	        contentType1.Alias = "newAlias";
+            contentType1.Alias = "newAlias";
             ServiceContext.ContentTypeService.Save(contentType1);
-            
+
             foreach (var c in contentItems1)
             {
                 var xml = DatabaseContext.Database.FirstOrDefault<ContentXmlDto>("WHERE nodeId = @Id", new { Id = c.Id });
                 Assert.IsNotNull(xml);
                 Assert.IsTrue(xml.Xml.StartsWith("<newAlias"));
             }
+
             foreach (var c in contentItems2)
             {
                 var xml = DatabaseContext.Database.FirstOrDefault<ContentXmlDto>("WHERE nodeId = @Id", new { Id = c.Id });
@@ -79,19 +80,20 @@ namespace Umbraco.Tests.Services
         [Test]
         public void Rebuild_Content_Xml_On_Property_Removal()
         {
-            var contentType1 = MockedContentTypes.CreateTextpageContentType("test1", "Test1");            
-            ServiceContext.ContentTypeService.Save(contentType1);            
+            var contentType1 = MockedContentTypes.CreateTextpageContentType("test1", "Test1");
+            ServiceContext.ContentTypeService.Save(contentType1);
             var contentItems1 = MockedContent.CreateTextpageContent(contentType1, -1, 10).ToArray();
-            contentItems1.ForEach(x => ServiceContext.ContentService.SaveAndPublish(x));
+            contentItems1.ForEach(x => ServiceContext.ContentService.SaveAndPublishWithStatus(x));
             var alias = contentType1.PropertyTypes.First().Alias;
             var elementToMatch = "<" + alias + ">";
+
             foreach (var c in contentItems1)
             {
                 var xml = DatabaseContext.Database.FirstOrDefault<ContentXmlDto>("WHERE nodeId = @Id", new { Id = c.Id });
                 Assert.IsNotNull(xml);
                 Assert.IsTrue(xml.Xml.Contains(elementToMatch)); //verify that it is there before we remove the property
             }
-            
+
             //remove a property
             contentType1.RemovePropertyType(contentType1.PropertyTypes.First().Alias);
             ServiceContext.ContentTypeService.Save(contentType1);
@@ -107,21 +109,21 @@ namespace Umbraco.Tests.Services
             }
         }
 
-	    [Test]
-	    public void Get_Descendants()
-	    {
-	        // Arrange
-	        var contentTypeService = ServiceContext.ContentTypeService;
-	        var hierarchy = CreateContentTypeHierarchy();
+        [Test]
+        public void Get_Descendants()
+        {
+            // Arrange
+            var contentTypeService = ServiceContext.ContentTypeService;
+            var hierarchy = CreateContentTypeHierarchy();
             contentTypeService.Save(hierarchy, 0); //ensure they are saved!
             var master = hierarchy.First();
 
             //Act
-	        var descendants = master.Descendants();
+            var descendants = master.Descendants();
 
             //Assert
             Assert.AreEqual(10, descendants.Count());
-	    }
+        }
 
         [Test]
         public void Get_Descendants_And_Self()
@@ -139,67 +141,97 @@ namespace Umbraco.Tests.Services
             Assert.AreEqual(11, descendants.Count());
         }
 
-	    [Test]
-		public void Can_Bulk_Save_New_Hierarchy_Content_Types()
-		{
-			// Arrange
-			var contentTypeService = ServiceContext.ContentTypeService;
-			var hierarchy = CreateContentTypeHierarchy();
+        [Test]
+        public void Can_Bulk_Save_New_Hierarchy_Content_Types()
+        {
+            // Arrange
+            var contentTypeService = ServiceContext.ContentTypeService;
+            var hierarchy = CreateContentTypeHierarchy();
 
-			// Act
-			contentTypeService.Save(hierarchy, 0);
+            // Act
+            contentTypeService.Save(hierarchy, 0);
 
-			Assert.That(hierarchy.Any(), Is.True);
-			Assert.That(hierarchy.Any(x => x.HasIdentity == false), Is.False);
-			//all parent id's should be ok, they are lazy and if they equal zero an exception will be thrown
-			Assert.DoesNotThrow(() => hierarchy.Any(x => x.ParentId != 0));
-			for (var i = 0; i < hierarchy.Count(); i++)
-			{
-				if (i == 0) continue;
-				Assert.AreEqual(hierarchy.ElementAt(i).ParentId, hierarchy.ElementAt(i - 1).Id);
-			}
-		}
+            Assert.That(hierarchy.Any(), Is.True);
+            Assert.That(hierarchy.Any(x => x.HasIdentity == false), Is.False);
+            //all parent id's should be ok, they are lazy and if they equal zero an exception will be thrown
+            Assert.DoesNotThrow(() => hierarchy.Any(x => x.ParentId != 0));
+            for (var i = 0; i < hierarchy.Count(); i++)
+            {
+                if (i == 0) continue;
+                Assert.AreEqual(hierarchy.ElementAt(i).ParentId, hierarchy.ElementAt(i - 1).Id);
+            }
+        }
 
-	    [Test]
-	    public void Can_Save_ContentType_Structure_And_Create_Content_Based_On_It()
-	    {
-	        // Arrange
-	        var cs = ServiceContext.ContentService;
-	        var cts = ServiceContext.ContentTypeService;
-	        var dtdYesNo = ServiceContext.DataTypeService.GetDataTypeDefinitionById(-49);
-	        var ctBase = new ContentType(-1) {Name = "Base", Alias = "Base", Icon = "folder.gif", Thumbnail = "folder.png"};
-	        ctBase.AddPropertyType(new PropertyType(dtdYesNo)
-	                                   {
-	                                       Name = "Hide From Navigation",
-	                                       Alias = Constants.Conventions.Content.NaviHide
-	                                   }
-	            /*,"Navigation"*/);
-	        cts.Save(ctBase);
+        [Test]
+        public void Can_Save_ContentType_Structure_And_Create_Content_Based_On_It()
+        {
+            // Arrange
+            var cs = ServiceContext.ContentService;
+            var cts = ServiceContext.ContentTypeService;
+            var dtdYesNo = ServiceContext.DataTypeService.GetDataTypeDefinitionById(-49);
+            var ctBase = new ContentType(-1) { Name = "Base", Alias = "Base", Icon = "folder.gif", Thumbnail = "folder.png" };
+            ctBase.AddPropertyType(new PropertyType(dtdYesNo)
+            {
+                Name = "Hide From Navigation",
+                Alias = Constants.Conventions.Content.NaviHide
+            }
+                /*,"Navigation"*/);
+            cts.Save(ctBase);
 
-	        var ctHomePage = new ContentType(ctBase)
-	                             {
-	                                 Name = "Home Page",
-	                                 Alias = "HomePage",
-	                                 Icon = "settingDomain.gif",
-	                                 Thumbnail = "folder.png",
-	                                 AllowedAsRoot = true
-	                             };
-	        ctHomePage.AddPropertyType(new PropertyType(dtdYesNo) {Name = "Some property", Alias = "someProperty"}
-	            /*,"Navigation"*/);
-	        cts.Save(ctHomePage);
+            var ctHomePage = new ContentType(ctBase)
+            {
+                Name = "Home Page",
+                Alias = "HomePage",
+                Icon = "settingDomain.gif",
+                Thumbnail = "folder.png",
+                AllowedAsRoot = true
+            };
+            ctHomePage.AddPropertyType(new PropertyType(dtdYesNo) { Name = "Some property", Alias = "someProperty" }
+                /*,"Navigation"*/);
+            cts.Save(ctHomePage);
 
-	        // Act
-	        var homeDoc = cs.CreateContent("Home Page", -1, "HomePage");
-	        cs.SaveAndPublish(homeDoc);
+            // Act
+            var homeDoc = cs.CreateContent("Home Page", -1, "HomePage");
+            cs.SaveAndPublishWithStatus(homeDoc);
 
-	        // Assert
-	        Assert.That(ctBase.HasIdentity, Is.True);
-	        Assert.That(ctHomePage.HasIdentity, Is.True);
-	        Assert.That(homeDoc.HasIdentity, Is.True);
-	        Assert.That(homeDoc.ContentTypeId, Is.EqualTo(ctHomePage.Id));
-	    }
+            // Assert
+            Assert.That(ctBase.HasIdentity, Is.True);
+            Assert.That(ctHomePage.HasIdentity, Is.True);
+            Assert.That(homeDoc.HasIdentity, Is.True);
+            Assert.That(homeDoc.ContentTypeId, Is.EqualTo(ctHomePage.Id));
+        }
 
-	    [Test]
+        [Test]
+        public void Create_Content_Type_Ensures_Sort_Orders()
+        {
+            var service = ServiceContext.ContentTypeService;
+
+            var contentType = new ContentType(-1)
+            {
+                Alias = "test",
+                Name = "Test",
+                Description = "ContentType used for simple text pages",
+                Icon = ".sprTreeDoc3",
+                Thumbnail = "doc2.png",
+                SortOrder = 1,
+                CreatorId = 0,
+                Trashed = false
+            };
+
+            contentType.AddPropertyType(new PropertyType(Constants.PropertyEditors.TextboxAlias, DataTypeDatabaseType.Ntext) { Alias = "title", Name = "Title", Description = "", Mandatory = false, DataTypeDefinitionId = -88 });
+            contentType.AddPropertyType(new PropertyType(Constants.PropertyEditors.TinyMCEAlias, DataTypeDatabaseType.Ntext) { Alias = "bodyText", Name = "Body Text", Description = "", Mandatory = false, DataTypeDefinitionId = -87 });
+            contentType.AddPropertyType(new PropertyType(Constants.PropertyEditors.TextboxAlias, DataTypeDatabaseType.Ntext) { Alias = "author", Name = "Author", Description = "Name of the author", Mandatory = false, DataTypeDefinitionId = -88 });
+
+            service.Save(contentType);
+
+            var sortOrders = contentType.PropertyTypes.Select(x => x.SortOrder).ToArray();
+
+            Assert.AreEqual(1, sortOrders.Count(x => x == 0));
+            Assert.AreEqual(1, sortOrders.Count(x => x == 1));
+            Assert.AreEqual(1, sortOrders.Count(x => x == 2));
+        }
+
+        [Test]
         public void Can_Create_And_Save_ContentType_Composition()
         {
             /*
@@ -266,9 +298,9 @@ namespace Umbraco.Tests.Services
         }
 
         [Test]
-	    public void Can_Copy_ContentType_By_Performing_Clone()
-	    {
-	        // Arrange
+        public void Can_Copy_ContentType_By_Performing_Clone()
+        {
+            // Arrange
             var service = ServiceContext.ContentTypeService;
             var metaContentType = MockedContentTypes.CreateMetaContentType();
             service.Save(metaContentType);
@@ -278,7 +310,7 @@ namespace Umbraco.Tests.Services
             var categoryId = simpleContentType.Id;
 
             // Act
-            var sut = simpleContentType.Clone("newcategory");
+            var sut = simpleContentType.DeepCloneWithResetIdentities("newcategory");
             service.Save(sut);
 
             // Assert
@@ -297,25 +329,24 @@ namespace Umbraco.Tests.Services
             Assert.AreNotEqual(contentType.SortOrder, category.SortOrder);
             Assert.AreNotEqual(contentType.PropertyTypes.First(x => x.Alias.Equals("title")).Id, category.PropertyTypes.First(x => x.Alias.Equals("title")).Id);
             Assert.AreNotEqual(contentType.PropertyGroups.First(x => x.Name.Equals("Content")).Id, category.PropertyGroups.First(x => x.Name.Equals("Content")).Id);
-            
-	    }
+        }
 
         [Test]
         public void Can_Copy_ContentType_To_New_Parent_By_Performing_Clone()
         {
             // Arrange
             var service = ServiceContext.ContentTypeService;
-            
+
             var parentContentType1 = MockedContentTypes.CreateSimpleContentType("parent1", "Parent1");
             service.Save(parentContentType1);
             var parentContentType2 = MockedContentTypes.CreateSimpleContentType("parent2", "Parent2");
             service.Save(parentContentType2);
-            
+
             var simpleContentType = MockedContentTypes.CreateSimpleContentType("category", "Category", parentContentType1);
             service.Save(simpleContentType);
 
             // Act
-            var clone = simpleContentType.Clone("newcategory");
+            var clone = simpleContentType.DeepCloneWithResetIdentities("newcategory");
             clone.RemoveContentType("parent1");
             clone.AddContentType(parentContentType2);
             clone.ParentId = parentContentType2.Id;
@@ -332,7 +363,7 @@ namespace Umbraco.Tests.Services
 
             Assert.AreEqual(clonedContentType.Path, "-1," + parentContentType2.Id + "," + clonedContentType.Id);
             Assert.AreEqual(clonedContentType.PropertyTypes.Count(), originalContentType.PropertyTypes.Count());
-            
+
             Assert.AreNotEqual(clonedContentType.ParentId, originalContentType.ParentId);
             Assert.AreEqual(clonedContentType.ParentId, parentContentType2.Id);
 
@@ -342,7 +373,6 @@ namespace Umbraco.Tests.Services
 
             Assert.AreNotEqual(clonedContentType.PropertyTypes.First(x => x.Alias.Equals("title")).Id, originalContentType.PropertyTypes.First(x => x.Alias.Equals("title")).Id);
             Assert.AreNotEqual(clonedContentType.PropertyGroups.First(x => x.Name.Equals("Content")).Id, originalContentType.PropertyGroups.First(x => x.Name.Equals("Content")).Id);
-
         }
 
         [Test]
@@ -366,12 +396,12 @@ namespace Umbraco.Tests.Services
             var cloned = service.GetContentType(clone.Id);
             var original = service.GetContentType(categoryId);
 
-
             Assert.That(cloned.CompositionAliases().Any(x => x.Equals("meta")), Is.False); //it's been copied to root
             Assert.AreEqual(cloned.ParentId, -1);
             Assert.AreEqual(cloned.Level, 1);
             Assert.AreEqual(cloned.PropertyTypes.Count(), original.PropertyTypes.Count());
             Assert.AreEqual(cloned.PropertyGroups.Count(), original.PropertyGroups.Count());
+
             for (int i = 0; i < cloned.PropertyGroups.Count; i++)
             {
                 Assert.AreEqual(cloned.PropertyGroups[i].PropertyTypes.Count, original.PropertyGroups[i].PropertyTypes.Count);
@@ -380,17 +410,18 @@ namespace Umbraco.Tests.Services
                     Assert.IsTrue(propertyType.HasIdentity);
                 }
             }
+
             foreach (var propertyType in cloned.PropertyTypes)
             {
                 Assert.IsTrue(propertyType.HasIdentity);
             }
+
             Assert.AreNotEqual(cloned.Id, original.Id);
             Assert.AreNotEqual(cloned.Key, original.Key);
             Assert.AreNotEqual(cloned.Path, original.Path);
             Assert.AreNotEqual(cloned.SortOrder, original.SortOrder);
             Assert.AreNotEqual(cloned.PropertyTypes.First(x => x.Alias.Equals("title")).Id, original.PropertyTypes.First(x => x.Alias.Equals("title")).Id);
             Assert.AreNotEqual(cloned.PropertyGroups.First(x => x.Name.Equals("Content")).Id, original.PropertyGroups.First(x => x.Name.Equals("Content")).Id);
-
         }
 
         [Test]
@@ -431,22 +462,21 @@ namespace Umbraco.Tests.Services
 
             Assert.AreNotEqual(clonedContentType.PropertyTypes.First(x => x.Alias.Equals("title")).Id, originalContentType.PropertyTypes.First(x => x.Alias.Equals("title")).Id);
             Assert.AreNotEqual(clonedContentType.PropertyGroups.First(x => x.Name.Equals("Content")).Id, originalContentType.PropertyGroups.First(x => x.Name.Equals("Content")).Id);
-
         }
 
         private ContentType CreateComponent()
         {
             var component = new ContentType(-1)
-                                  {
-                                      Alias = "component",
-                                      Name = "Component",
-                                      Description = "ContentType used for Component grouping",
-                                      Icon = ".sprTreeDoc3",
-                                      Thumbnail = "doc.png",
-                                      SortOrder = 1,
-                                      CreatorId = 0,
-                                      Trashed = false
-                                  };
+            {
+                Alias = "component",
+                Name = "Component",
+                Description = "ContentType used for Component grouping",
+                Icon = ".sprTreeDoc3",
+                Thumbnail = "doc.png",
+                SortOrder = 1,
+                CreatorId = 0,
+                Trashed = false
+            };
 
             var contentCollection = new PropertyTypeCollection();
             contentCollection.Add(new PropertyType("test", DataTypeDatabaseType.Ntext) { Alias = "componentGroup", Name = "Component Group", Description = "", HelpText = "", Mandatory = false, SortOrder = 1, DataTypeDefinitionId = -88 });
@@ -458,27 +488,26 @@ namespace Umbraco.Tests.Services
         private ContentType CreateBannerComponent(ContentType parent)
         {
             var banner = new ContentType(parent)
-                                {
-                                    Alias = "banner",
-                                    Name = "Banner Component",
-                                    Description = "ContentType used for Banner Component",
-                                    Icon = ".sprTreeDoc3",
-                                    Thumbnail = "doc.png",
-                                    SortOrder = 1,
-                                    CreatorId = 0,
-                                    Trashed = false
-                                };
+            {
+                Alias = "banner",
+                Name = "Banner Component",
+                Description = "ContentType used for Banner Component",
+                Icon = ".sprTreeDoc3",
+                Thumbnail = "doc.png",
+                SortOrder = 1,
+                CreatorId = 0,
+                Trashed = false
+            };
 
             var propertyType = new PropertyType("test", DataTypeDatabaseType.Ntext)
-                {
-                    Alias = "bannerName",
-                    Name = "Banner Name",
-                    Description = "",
-                    HelpText = "",
-                    Mandatory = false,
-                    SortOrder = 2,
-                    DataTypeDefinitionId = -88
-                };
+            {
+                Alias = "bannerName",
+                Name = "Banner Name",
+                Description = "",
+                Mandatory = false,
+                SortOrder = 2,
+                DataTypeDefinitionId = -88
+            };
             banner.AddPropertyType(propertyType, "Component");
             return banner;
         }
@@ -486,16 +515,16 @@ namespace Umbraco.Tests.Services
         private ContentType CreateSite()
         {
             var site = new ContentType(-1)
-                           {
-                               Alias = "site",
-                               Name = "Site",
-                               Description = "ContentType used for Site inheritence",
-                               Icon = ".sprTreeDoc3",
-                               Thumbnail = "doc.png",
-                               SortOrder = 2,
-                               CreatorId = 0,
-                               Trashed = false
-                           };
+            {
+                Alias = "site",
+                Name = "Site",
+                Description = "ContentType used for Site inheritence",
+                Icon = ".sprTreeDoc3",
+                Thumbnail = "doc.png",
+                SortOrder = 2,
+                CreatorId = 0,
+                Trashed = false
+            };
 
             var contentCollection = new PropertyTypeCollection();
             contentCollection.Add(new PropertyType("test", DataTypeDatabaseType.Ntext) { Alias = "hostname", Name = "Hostname", Description = "", HelpText = "", Mandatory = false, SortOrder = 1, DataTypeDefinitionId = -88 });
@@ -507,16 +536,16 @@ namespace Umbraco.Tests.Services
         private ContentType CreateHomepage(ContentType parent)
         {
             var contentType = new ContentType(parent)
-                             {
-                                 Alias = "homepage",
-                                 Name = "Homepage",
-                                 Description = "ContentType used for the Homepage",
-                                 Icon = ".sprTreeDoc3",
-                                 Thumbnail = "doc.png",
-                                 SortOrder = 1,
-                                 CreatorId = 0,
-                                 Trashed = false
-                             };
+            {
+                Alias = "homepage",
+                Name = "Homepage",
+                Description = "ContentType used for the Homepage",
+                Icon = ".sprTreeDoc3",
+                Thumbnail = "doc.png",
+                SortOrder = 1,
+                CreatorId = 0,
+                Trashed = false
+            };
 
             var contentCollection = new PropertyTypeCollection();
             contentCollection.Add(new PropertyType("test", DataTypeDatabaseType.Ntext) { Alias = "title", Name = "Title", Description = "", HelpText = "", Mandatory = false, SortOrder = 1, DataTypeDefinitionId = -88 });
@@ -528,26 +557,26 @@ namespace Umbraco.Tests.Services
             return contentType;
         }
 
-		private IContentType[] CreateContentTypeHierarchy()
-		{
-			//create the master type
-			var masterContentType = MockedContentTypes.CreateSimpleContentType("masterContentType", "MasterContentType");
-			masterContentType.Key = new Guid("C00CA18E-5A9D-483B-A371-EECE0D89B4AE");
-			ServiceContext.ContentTypeService.Save(masterContentType);
+        private IContentType[] CreateContentTypeHierarchy()
+        {
+            //create the master type
+            var masterContentType = MockedContentTypes.CreateSimpleContentType("masterContentType", "MasterContentType");
+            masterContentType.Key = new Guid("C00CA18E-5A9D-483B-A371-EECE0D89B4AE");
+            ServiceContext.ContentTypeService.Save(masterContentType);
 
-			//add the one we just created
-			var list = new List<IContentType> {masterContentType};
-			
-			for (var i = 0; i < 10; i++)
-			{
-				var contentType = MockedContentTypes.CreateSimpleContentType("childType" + i, "ChildType" + i, 
-					//make the last entry in the list, this one's parent
-					list.Last());
+            //add the one we just created
+            var list = new List<IContentType> { masterContentType };
 
-				list.Add(contentType);				
-			}
+            for (var i = 0; i < 10; i++)
+            {
+                var contentType = MockedContentTypes.CreateSimpleContentType("childType" + i, "ChildType" + i,
+                    //make the last entry in the list, this one's parent
+                    list.Last());
 
-		    return list.ToArray();
-		}
-	}
+                list.Add(contentType);
+            }
+
+            return list.ToArray();
+        }
+    }
 }

src/Umbraco.Tests/Services/EntityServiceTests.cs

@@ -138,6 +138,16 @@ namespace Umbraco.Tests.Services
                         && ((UmbracoEntity.EntityProperty)y.Value).PropertyEditorAlias == Constants.PropertyEditors.UploadFieldAlias)), Is.True);
         }
 
+        [Test]
+        public void EntityService_Can_Get_ObjectType()
+        {
+            var service = ServiceContext.EntityService;
+            var mediaObjectType = service.GetObjectType(1031);
+
+            Assert.NotNull(mediaObjectType);
+            Assert.AreEqual(mediaObjectType, UmbracoObjectTypes.MediaType);
+        }
+
         private static bool _isSetup = false;
 
         public override void CreateTestData()

src/Umbraco.Tests/Services/LocalizationServiceTests.cs

@@ -1,4 +1,8 @@
-using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Umbraco.Core.Models;
 using Umbraco.Tests.TestHelpers;
 
 namespace Umbraco.Tests.Services
@@ -8,10 +12,17 @@ namespace Umbraco.Tests.Services
     /// This is more of an integration test as it involves multiple layers
     /// as well as configuration.
     /// </summary>
-    [DatabaseTestBehavior(DatabaseBehavior.NewDbFileAndSchemaPerFixture)]
+    [DatabaseTestBehavior(DatabaseBehavior.NewDbFileAndSchemaPerTest)]
     [TestFixture, RequiresSTA]
     public class LocalizationServiceTests : BaseServiceTest
     {
+        private Guid _parentItemGuidId;
+        private int _parentItemIntId;
+        private Guid _childItemGuidId;
+        private int _childItemIntId;
+        private int _danishLangId;
+        private int _englishLangId;
+
         [SetUp]
         public override void Initialize()
         {
@@ -23,5 +34,194 @@ namespace Umbraco.Tests.Services
         {
             base.TearDown();
         }
+
+        [Test]
+        public void LocalizationService_Can_Get_Root_Dictionary_Items()
+        {
+            var rootItems = ServiceContext.LocalizationService.GetRootDictionaryItems();
+
+            Assert.NotNull(rootItems);
+            Assert.IsTrue(rootItems.Any());
+        }
+
+        [Test]
+        public void LocalizationService_Can_Determint_If_DictionaryItem_Exists()
+        {
+            var exists = ServiceContext.LocalizationService.DictionaryItemExists("Parent");
+            Assert.IsTrue(exists);
+        }
+
+        [Test]
+        public void LocalizationService_Can_Get_All_Languages()
+        {
+            var languages = ServiceContext.LocalizationService.GetAllLanguages();
+            Assert.NotNull(languages);
+            Assert.IsTrue(languages.Any());
+            Assert.That(languages.Count(), Is.EqualTo(3));
+        }
+
+        [Test]
+        public void LocalizationService_Can_Get_Dictionary_Item_By_Int_Id()
+        {
+            var parentItem = ServiceContext.LocalizationService.GetDictionaryItemById(_parentItemIntId);
+            Assert.NotNull(parentItem);
+
+            var childItem = ServiceContext.LocalizationService.GetDictionaryItemById(_childItemIntId);
+            Assert.NotNull(childItem);
+        }
+
+        [Test]
+        public void LocalizationService_Can_Get_Dictionary_Item_By_Guid_Id()
+        {
+            var parentItem = ServiceContext.LocalizationService.GetDictionaryItemById(_parentItemGuidId);
+            Assert.NotNull(parentItem);
+
+            var childItem = ServiceContext.LocalizationService.GetDictionaryItemById(_childItemGuidId);
+            Assert.NotNull(childItem);
+        }
+
+        [Test]
+        public void LocalizationService_Can_Get_Dictionary_Item_By_Key()
+        {
+            var parentItem = ServiceContext.LocalizationService.GetDictionaryItemByKey("Parent");
+            Assert.NotNull(parentItem);
+
+            var childItem = ServiceContext.LocalizationService.GetDictionaryItemByKey("Child");
+            Assert.NotNull(childItem);
+        }
+
+        [Test]
+        public void LocalizationService_Can_Get_Dictionary_Item_Children()
+        {
+            var item = ServiceContext.LocalizationService.GetDictionaryItemChildren(_parentItemGuidId);
+            Assert.NotNull(item);
+            Assert.That(item.Count(), Is.EqualTo(1));
+
+            foreach (var dictionaryItem in item)
+            {
+                Assert.IsFalse(string.IsNullOrEmpty(dictionaryItem.ItemKey));
+            }
+        }
+
+        [Test]
+        public void LocalizationService_Can_Get_Language_By_Culture_Code()
+        {
+            var danish = ServiceContext.LocalizationService.GetLanguageByCultureCode("Danish");
+            var english = ServiceContext.LocalizationService.GetLanguageByCultureCode("English");
+            Assert.NotNull(danish);
+            Assert.NotNull(english);
+        }
+
+        [Test]
+        public void LocalizationService_Can_GetLanguageById()
+        {
+            var danish = ServiceContext.LocalizationService.GetLanguageById(_danishLangId);
+            var english = ServiceContext.LocalizationService.GetLanguageById(_englishLangId);
+            Assert.NotNull(danish);
+            Assert.NotNull(english);
+        }
+
+        [Test]
+        public void LocalizationService_Can_GetLanguageByIsoCode()
+        {
+            var danish = ServiceContext.LocalizationService.GetLanguageByIsoCode("da-DK");
+            var english = ServiceContext.LocalizationService.GetLanguageByIsoCode("en-GB");
+            Assert.NotNull(danish);
+            Assert.NotNull(english);
+        }
+
+        [Test]
+        public void LocalizationService_Does_Not_Fail_When_Language_Doesnt_Exist()
+        {
+            var language = ServiceContext.LocalizationService.GetLanguageByIsoCode("sv-SE");
+            Assert.Null(language);
+        }
+
+        [Test]
+        public void LocalizationService_Does_Not_Fail_When_DictionaryItem_Doesnt_Exist()
+        {
+            var item = ServiceContext.LocalizationService.GetDictionaryItemByKey("RandomKey");
+            Assert.Null(item);
+        }
+
+        [Test]
+        public void LocalizationService_Can_Delete_Language()
+        {
+            var norwegian = new Language("nb-NO") { CultureName = "Norwegian" };
+            ServiceContext.LocalizationService.Save(norwegian, 0);
+            Assert.That(norwegian.HasIdentity, Is.True);
+            var languageId = norwegian.Id;
+
+            ServiceContext.LocalizationService.Delete(norwegian);
+
+            var language = ServiceContext.LocalizationService.GetLanguageById(languageId);
+            Assert.Null(language);
+        }
+
+        [Test]
+        public void LocalizationService_Can_Delete_DictionaryItem()
+        {
+            var item = ServiceContext.LocalizationService.GetDictionaryItemByKey("Child");
+            Assert.NotNull(item);
+
+            ServiceContext.LocalizationService.Delete(item);
+
+            var deletedItem = ServiceContext.LocalizationService.GetDictionaryItemByKey("Child");
+            Assert.Null(deletedItem);
+        }
+
+        [Test]
+        public void LocalizationService_Can_Update_Existing_DictionaryItem()
+        {
+            var item = ServiceContext.LocalizationService.GetDictionaryItemByKey("Child");
+            foreach (var translation in item.Translations)
+            {
+                translation.Value = translation.Value + "UPDATED";
+            }
+
+            ServiceContext.LocalizationService.Save(item);
+
+            var updatedItem = ServiceContext.LocalizationService.GetDictionaryItemByKey("Child");
+            Assert.NotNull(updatedItem);
+
+            foreach (var translation in updatedItem.Translations)
+            {
+                Assert.That(translation.Value.EndsWith("UPDATED"), Is.True);
+            }
+        }
+
+        public override void CreateTestData()
+        {
+            var danish = new Language("da-DK") { CultureName = "Danish" };
+            var english = new Language("en-GB") { CultureName = "English"};
+            ServiceContext.LocalizationService.Save(danish, 0);
+            ServiceContext.LocalizationService.Save(english, 0);
+            _danishLangId = danish.Id;
+            _englishLangId = english.Id;
+
+            var parentItem = new DictionaryItem("Parent")
+            {
+                Translations = new List<IDictionaryTranslation>
+                               {
+                                   new DictionaryTranslation(english, "ParentValue"),
+                                   new DictionaryTranslation(danish, "ForældreVærdi")
+                               }
+            };
+            ServiceContext.LocalizationService.Save(parentItem);
+            _parentItemGuidId = parentItem.Key;
+            _parentItemIntId = parentItem.Id;
+
+            var childItem = new DictionaryItem(parentItem.Key, "Child")
+                            {
+                                Translations = new List<IDictionaryTranslation>
+                                               {
+                                                   new DictionaryTranslation(english, "ChildValue"),
+                                                   new DictionaryTranslation(danish, "BørnVærdi")
+                                               }
+                            };
+            ServiceContext.LocalizationService.Save(childItem);
+            _childItemGuidId = childItem.Key;
+            _childItemIntId = childItem.Id;
+        }
     }
 }

src/Umbraco.Tests/Services/MacroServiceTests.cs

@@ -150,6 +150,40 @@ namespace Umbraco.Tests.Services
 
         }
 
+        [Test]
+        public void Can_Add_And_Remove_Properties()
+        {
+            var macroService = ServiceContext.MacroService;
+            var macro = new Macro("test", "Test", scriptPath: "~/Views/MacroPartials/Test.cshtml", cacheDuration: 1234);
+            
+            //adds some properties
+            macro.Properties.Add(new MacroProperty("blah1", "Blah1", 0, "blah1"));
+            macro.Properties.Add(new MacroProperty("blah2", "Blah2", 0, "blah2"));
+            macro.Properties.Add(new MacroProperty("blah3", "Blah3", 0, "blah3"));
+            macro.Properties.Add(new MacroProperty("blah4", "Blah4", 0, "blah4"));
+            macroService.Save(macro);
+
+            var result1 = macroService.GetById(macro.Id);
+            Assert.AreEqual(4, result1.Properties.Count());
+
+            //simulate clearing the sections
+            foreach (var s in result1.Properties.ToArray())
+            {
+                result1.Properties.Remove(s.Alias);
+            }
+            //now just re-add a couple
+            result1.Properties.Add(new MacroProperty("blah3", "Blah3", 0, "blah3"));
+            result1.Properties.Add(new MacroProperty("blah4", "Blah4", 0, "blah4"));
+            macroService.Save(result1);
+
+            //assert
+
+            //re-get
+            result1 = macroService.GetById(result1.Id);
+            Assert.AreEqual(2, result1.Properties.Count());
+
+        }
+
         //[Test]
         //public void Can_Get_Many_By_Alias()
         //{

src/Umbraco.Tests/Umbraco.Tests.csproj

@@ -191,6 +191,7 @@
     <Compile Include="Models\LanguageTests.cs" />
     <Compile Include="Models\MemberGroupTests.cs" />
     <Compile Include="Models\MemberTests.cs" />
+    <Compile Include="Models\PreValueCollectionTests.cs" />
     <Compile Include="Models\PropertyGroupTests.cs" />
     <Compile Include="Models\PropertyTypeTests.cs" />
     <Compile Include="Models\RelationTests.cs" />

src/Umbraco.Web.UI.Client/bower.json

@@ -16,6 +16,8 @@
     "tests"
   ],
   "dependencies": {
-    "typeahead.js": "~0.10.2"
+    "typeahead.js": "~0.10.2",
+    "ace-builds": "~1.1.3",
+    "rgrove-lazyload": "*"
   }
 }

src/Umbraco.Web.UI.Client/gruntFile.js

@@ -6,15 +6,16 @@ module.exports = function (grunt) {
   grunt.registerTask('dev', ['jshint:dev', 'build', 'webserver', 'open:dev', 'watch']);
 
   //run by the watch task
-  grunt.registerTask('watch-js', ['jshint:dev','concat','copy:app','copy:mocks','copy:packages','copy:vs','karma:unit']);
-  grunt.registerTask('watch-less', ['recess:build','recess:installer','copy:assets','copy:vs']);
+  grunt.registerTask('watch-js', ['jshint:dev','concat','copy:app','copy:mocks','copy:packages','copy:tuning','copy:vs','karma:unit']);
+  grunt.registerTask('watch-less', ['recess:build', 'recess:installer', 'recess:tuning','copy:tuning', 'copy:assets', 'copy:vs']);
   grunt.registerTask('watch-html', ['copy:views', 'copy:vs']);
   grunt.registerTask('watch-packages', ['copy:packages']);
-  grunt.registerTask('watch-installer', ['concat:install','concat:installJs','copy:installer', 'copy:vs']);
+  grunt.registerTask('watch-installer', ['concat:install', 'concat:installJs', 'copy:installer', 'copy:vs']);
+  grunt.registerTask('watch-tuning', ['copy:tuning', 'concat:tuningJs', 'copy:vs']);
   grunt.registerTask('watch-test', ['jshint:dev', 'karma:unit']);
 
   //triggered from grunt dev or grunt
-  grunt.registerTask('build', ['clean','concat','recess:min','recess:installer','copy']);
+  grunt.registerTask('build', ['clean', 'concat', 'recess:min', 'recess:installer', 'recess:tuning', 'bower', 'copy']);
 
   //utillity tasks
   grunt.registerTask('docs', ['ngdocs']);
@@ -109,23 +110,48 @@ module.exports = function (grunt) {
     clean: ['<%= distdir %>/*'],
 
     copy: {
-
-      /* Copies over the files downloaded by bower
-      bower: {
-          files: [
-              { dest: '<%= distdir %>/lib/typeahead/typeahead.bundle.min.js', src: '<%= bowerfiles %>/typeahead.js/dist/typeahead.bundle.min.js' }
-          ]
-      },
-      */
-
       assets: {
         files: [{ dest: '<%= distdir %>/assets', src : '**', expand: true, cwd: 'src/assets/' }]
       },
 
+
+      // Copies over the files downloaded by bower
+      bower: {
+        files: [
+                {
+                  dest: '<%= distdir %>/lib/typeahead/typeahead.bundle.min.js', 
+                  src: 'bower_components/typeahead.js/dist/typeahead.bundle.min.js' 
+                },
+                {
+                  dest: '<%= distdir %>/lib/lazyload/lazyload.min.js', 
+                  src: 'bower_components/rgrove-lazyload/lazyload.js'
+                },
+                {
+                  dest: '<%= distdir %>/lib/ace/',
+                  src: '**',
+                  expand: true,
+                  cwd: 'bower_components/ace-builds/src-min-noconflict/'
+                }
+              ]
+      },
+      
+
       installer: {
         files: [{ dest: '<%= distdir %>/views/install', src : '**/*.html', expand: true, cwd: 'src/installer/steps' }]
       },
 
+      tuning: {
+          files: [
+              { dest: '<%= distdir %>/preview', src: '**/*.html', expand: true, cwd: 'src/tuning' },
+              { dest: '<%= distdir %>/assets/css', src: 'tuning.defaultStyle.css', expand: true, cwd: 'src/tuning' },
+              { dest: '<%= distdir %>/assets/less', src: 'tuning.defaultStyle.less', expand: true, cwd: 'src/tuning' },
+              { dest: '<%= distdir %>/assets/less', src: 'tuning.gridRowStyle.less', expand: true, cwd: 'src/tuning' },
+              { dest: '<%= distdir %>/js', src: 'tuning.config.js', expand: true, cwd: 'src/tuning/config' },
+              { dest: '<%= distdir %>/js', src: 'tuning.palettes.js', expand: true, cwd: 'src/tuning/config' },
+              { dest: '<%= distdir %>/js', src: 'tuning.front.js', expand: true, cwd: 'src/tuning' }
+          ]
+      },
+
       vendor: {
         files: [{ dest: '<%= distdir %>/lib', src : '**', expand: true, cwd: 'lib/' }]
       },
@@ -147,7 +173,8 @@ module.exports = function (grunt) {
               { dest: '<%= vsdir %>/assets', src: '**', expand: true, cwd: '<%= distdir %>/assets' },
               { dest: '<%= vsdir %>/js', src: '**', expand: true, cwd: '<%= distdir %>/js' },
               { dest: '<%= vsdir %>/lib', src: '**', expand: true, cwd: '<%= distdir %>/lib' },
-              { dest: '<%= vsdir %>/views', src: '**', expand: true, cwd: '<%= distdir %>/views' }
+              { dest: '<%= vsdir %>/views', src: '**', expand: true, cwd: '<%= distdir %>/views' },
+              { dest: '<%= vsdir %>/preview', src: '**', expand: true, cwd: '<%= distdir %>/preview' }
           ]
       },
 
@@ -186,6 +213,10 @@ module.exports = function (grunt) {
               footer: "\n\n})();"
           }
         },
+        tuningJs: {
+            src: ['src/tuning/tuning.global.js', 'src/tuning/tuning.controller.js', 'src/tuning/lib/slider.directive.js', 'src/tuning/lib/spectrum.directive.js'],
+            dest: '<%= distdir %>/js/tuning.panel.js'
+        },
         controllers: {
           src:['src/controllers/**/*.controller.js','src/views/**/*.controller.js'],
           dest: '<%= distdir %>/js/umbraco.controllers.js',
@@ -272,6 +303,15 @@ module.exports = function (grunt) {
           compile: true
         }
       },
+      tuning: {
+          files: {
+              '<%= distdir %>/assets/css/tuning.panelStyles.css':
+              ['src/less/tuning.panelStyles.less', 'src/less/helveticons.less']
+          },
+          options: {
+              compile: true
+          }
+      },
       min: {
         files: {
           '<%= distdir %>/assets/css/<%= pkg.name %>.css': ['<%= src.less %>']
@@ -304,6 +344,10 @@ module.exports = function (grunt) {
           files: ['src/installer/**/*.*'],
           tasks: ['watch-installer', 'timestamp'],
       },
+      tuning: {
+          files: ['src/tuning/**/*.*'],
+          tasks: ['watch-tuning', 'timestamp'],
+      },
       html: {
         files: ['src/views/**/*.html', 'src/*.html'],
         tasks:['watch-html','timestamp']

src/Umbraco.Web.UI.Client/lib/bootstrap/less/code.less

@@ -5,7 +5,7 @@
 
 // Inline and block code styles
 code,
-pre {
+pre.code {
   padding: 0 3px 2px;
   #font > #family > .monospace;
   font-size: @baseFontSize - 2;
@@ -23,7 +23,7 @@ code {
 }
 
 // Blocks of code
-pre {
+pre.code {
   display: block;
   padding: (@baseLineHeight - 1) / 2;
   margin: 0 0 @baseLineHeight / 2;