From 6b4fff176a21e84b2184cfa5640293ebaef760c3 Mon Sep 17 00:00:00 2001
From: sgay <unknown@kiln.example.com>
Date: Thu, 26 Jul 2012 07:52:13 -0200
Subject: [PATCH 1/3] refactor resolution of components

---
 .../Resolving/ManyWeightedResolved.cs         | 159 ++++++++++++++++++
 .../Resolving/ManyWeightedResolverBase.cs     |  66 ++++++++
 src/Umbraco.Core/Resolving/Resolution.cs      |  34 ++++
 .../Resolving/ResolutionWeightAttribute.cs    |  26 +++
 src/Umbraco.Core/Resolving/ResolverBase.cs    |  36 ++++
 src/Umbraco.Core/Resolving/SingleResolved.cs  |  48 ++++++
 .../Resolving/SingleResolverBase.cs           |  48 ++++++
 src/Umbraco.Core/TypeExtensions.cs            |  20 +++
 src/Umbraco.Core/Umbraco.Core.csproj          |   9 +
 src/Umbraco.Web/Routing/DocumentRequest.cs    |   7 +-
 src/Umbraco.Web/Routing/IRoutesCache.cs       |   8 +
 .../NiceUrlProvider.cs}                       |  33 +++-
 .../RequestDocumentResolverWeightAttribute.cs |  31 ----
 .../RequestDocumentResolversResolver.cs       |  48 ++++++
 src/Umbraco.Web/Routing/ResolveByAlias.cs     |   3 +-
 src/Umbraco.Web/Routing/ResolveById.cs        |   3 +-
 src/Umbraco.Web/Routing/ResolveByNiceUrl.cs   |   3 +-
 .../Routing/ResolveByNiceUrlAndTemplate.cs    |   3 +-
 src/Umbraco.Web/Routing/ResolveByProfile.cs   |   3 +-
 src/Umbraco.Web/Routing/RouteLookups.cs       | 111 ------------
 src/Umbraco.Web/Routing/RoutesCache.cs        |  61 -------
 .../Routing/RoutesCacheResolver.cs            |  18 ++
 src/Umbraco.Web/Routing/RoutingContext.cs     |  19 +--
 src/Umbraco.Web/Umbraco.Web.csproj            |  11 +-
 src/Umbraco.Web/UmbracoApplication.cs         |   7 +-
 src/Umbraco.Web/UmbracoContext.cs             |   2 +-
 src/Umbraco.Web/UmbracoModule.cs              |   7 +-
 .../umbraco.presentation/library.cs           |  12 +-
 28 files changed, 591 insertions(+), 245 deletions(-)
 create mode 100644 src/Umbraco.Core/Resolving/ManyWeightedResolved.cs
 create mode 100644 src/Umbraco.Core/Resolving/ManyWeightedResolverBase.cs
 create mode 100644 src/Umbraco.Core/Resolving/Resolution.cs
 create mode 100644 src/Umbraco.Core/Resolving/ResolutionWeightAttribute.cs
 create mode 100644 src/Umbraco.Core/Resolving/ResolverBase.cs
 create mode 100644 src/Umbraco.Core/Resolving/SingleResolved.cs
 create mode 100644 src/Umbraco.Core/Resolving/SingleResolverBase.cs
 create mode 100644 src/Umbraco.Core/TypeExtensions.cs
 rename src/Umbraco.Web/{NiceUrlResolver.cs => Routing/NiceUrlProvider.cs} (73%)
 delete mode 100644 src/Umbraco.Web/Routing/RequestDocumentResolverWeightAttribute.cs
 create mode 100644 src/Umbraco.Web/Routing/RequestDocumentResolversResolver.cs
 delete mode 100644 src/Umbraco.Web/Routing/RouteLookups.cs
 delete mode 100644 src/Umbraco.Web/Routing/RoutesCache.cs
 create mode 100644 src/Umbraco.Web/Routing/RoutesCacheResolver.cs

diff --git a/src/Umbraco.Core/Resolving/ManyWeightedResolved.cs b/src/Umbraco.Core/Resolving/ManyWeightedResolved.cs
new file mode 100644
index 0000000000..c8d56b8c67
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/ManyWeightedResolved.cs
@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Umbraco.Core.Resolving
+{
+	public class ManyWeightedResolved<TResolved>
+	{
+		List<TResolved> _resolved = new List<TResolved>();
+		Dictionary<Type, int> _weights = new Dictionary<Type, int>();
+
+		public ManyWeightedResolved()
+		{
+			Resolution.Frozen += (sender, e) =>
+				{
+					_resolved = _resolved.OrderBy(r => _weights[r.GetType()]).ToList();
+					_weights = null;
+				};
+		}
+
+		public ManyWeightedResolved(IEnumerable<TResolved> resolved)
+			: this()
+		{
+			_resolved.AddRange(resolved);
+			foreach (var type in _resolved.Select(r => r.GetType()))
+				_weights.Add(type, ResolutionWeightAttribute.ReadWeight(type));
+		}
+
+		public IEnumerable<TResolved> Values
+		{
+			get { return _resolved; }
+		}
+
+		#region Manage collection
+
+		public void Add(TResolved value)
+		{
+			Resolution.EnsureNotFrozen();
+
+			var type = value.GetType();
+			EnsureNotExists(type);
+			_resolved.Add(value);
+			_weights[type] = ResolutionWeightAttribute.ReadWeight(type);
+		}
+
+		public void Add(TResolved value, int weight)
+		{
+			Resolution.EnsureNotFrozen();
+
+			var type = value.GetType();
+			EnsureNotExists(type);
+			_resolved.Add(value);
+			_weights[type] = weight;
+		}
+
+		public void AddRange(IEnumerable<TResolved> values)
+		{
+			Resolution.EnsureNotFrozen();
+
+			foreach (var value in values)
+			{
+				var type = value.GetType();
+				EnsureNotExists(type);
+				_resolved.Add(value);
+				_weights[type] = ResolutionWeightAttribute.ReadWeight(type);
+			}
+		}
+
+		//public void SetWeight(TResolved value, int weight)
+		//{
+		//    Resolution.EnsureNotFrozen();
+
+		//    var type = value.GetType();
+		//    EnsureExists(type);
+		//    _weights[type] = weight;
+		//}
+
+		public void SetWeight<TResolving>(int weight)
+		{
+			Resolution.EnsureNotFrozen();
+
+			var type = typeof(TResolving);
+			EnsureExists(type);
+			_weights[type] = weight;
+		}
+
+		//public int GetWeight(TResolved value)
+		//{
+		//    var type = value.GetType();
+		//    EnsureExists(type);
+		//    return _weights[value.GetType()];
+		//}
+
+		public int GetWeight<TResolving>()
+		{
+			var type = typeof(TResolving);
+			EnsureExists(type);
+			return _weights[type];
+		}
+
+		//public void Remove(TResolved value)
+		//{
+		//    Resolution.EnsureNotFrozen();
+
+		//    var type = value.GetType();
+		//    var remove = _resolved.SingleOrDefault(r => r.GetType() == type);
+		//    if (remove != null)
+		//    {
+		//        _resolved.Remove(remove);
+		//        _weights.Remove(remove.GetType());
+		//    }
+		//}
+
+		public void Remove<TResolving>()
+		{
+			Resolution.EnsureNotFrozen();
+
+			var type = typeof(TResolving);
+			var remove = _resolved.SingleOrDefault(r => r.GetType() == type);
+			if (remove != null)
+			{
+				_resolved.Remove(remove);
+				_weights.Remove(remove.GetType());
+			}
+		}
+
+		public void Clear()
+		{
+			Resolution.EnsureNotFrozen();
+
+			_resolved = new List<TResolved>();
+			_weights = new Dictionary<Type, int>();
+		}
+
+		#endregion
+
+		#region Utilities
+
+		public bool Exists(Type type)
+		{
+			return _resolved.Any(r => r.GetType() == type);
+		}
+
+		void EnsureExists(Type type)
+		{
+			if (!Exists(type))
+				throw new InvalidOperationException("There is not value of that type in the collection.");
+		}
+
+		void EnsureNotExists(Type type)
+		{
+			if (Exists(type))
+				throw new InvalidOperationException("A value of that type already exists in the collection.");
+		}
+
+		#endregion
+	}
+}
diff --git a/src/Umbraco.Core/Resolving/ManyWeightedResolverBase.cs b/src/Umbraco.Core/Resolving/ManyWeightedResolverBase.cs
new file mode 100644
index 0000000000..fb68db0d47
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/ManyWeightedResolverBase.cs
@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Umbraco.Core.Resolving
+{
+	public abstract class ManyWeightedResolverBase<TResolver, TResolved> : ResolverBase<TResolver>
+	{
+		ManyWeightedResolved<TResolved> _resolved;
+
+		protected ManyWeightedResolverBase()
+		{
+			_resolved = new ManyWeightedResolved<TResolved>();
+		}
+
+		protected ManyWeightedResolverBase(IEnumerable<TResolved> values)
+		{
+			_resolved = new ManyWeightedResolved<TResolved>(values);
+		}
+
+		protected IEnumerable<TResolved> Values
+		{
+			get { return _resolved.Values; }
+		}
+
+		#region Manage collection
+
+		public void Add(TResolved value)
+		{
+			_resolved.Add(value);
+		}
+
+		public void Add(TResolved value, int weight)
+		{
+			_resolved.Add(value, weight);
+		}
+
+		public void AddRange(IEnumerable<TResolved> values)
+		{
+			_resolved.AddRange(values);
+		}
+
+		public void SetWeight<TResolving>(int weight)
+		{
+			_resolved.SetWeight<TResolving>(weight);
+		}
+
+		public int GetWeight<TResolving>()
+		{
+			return _resolved.GetWeight<TResolving>();
+		}
+
+		public void Remove<TResolving>()
+		{
+			_resolved.Remove<TResolving>();
+		}
+
+		public void Clear()
+		{
+			_resolved.Clear();
+		}
+
+		#endregion
+	}
+}
diff --git a/src/Umbraco.Core/Resolving/Resolution.cs b/src/Umbraco.Core/Resolving/Resolution.cs
new file mode 100644
index 0000000000..96349d645b
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/Resolution.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Umbraco.Core.Resolving
+{
+	// notes: nothing in Resolving is thread-safe because everything should happen when the app is starting
+
+	public class Resolution
+	{
+		public static event EventHandler Freezing;
+		public static event EventHandler Frozen;
+
+		public static bool IsFrozen { get; private set; }
+
+		public static void EnsureNotFrozen()
+		{
+			if (Resolution.IsFrozen)
+				throw new InvalidOperationException("Resolution is frozen. It is not possible to modify resolvers once resolution is frozen.");
+		}
+
+		public static void Freeze()
+		{
+			if (Resolution.IsFrozen)
+				throw new InvalidOperationException("Resolution is frozen. It is not possible to freeze it again.");
+			if (Freezing != null)
+				Freezing(null, null);
+			IsFrozen = true;
+			if (Frozen != null)
+				Frozen(null, null);
+		}
+	}
+}
diff --git a/src/Umbraco.Core/Resolving/ResolutionWeightAttribute.cs b/src/Umbraco.Core/Resolving/ResolutionWeightAttribute.cs
new file mode 100644
index 0000000000..c31e0a6b66
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/ResolutionWeightAttribute.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Umbraco.Core.Resolving
+{
+	[AttributeUsage(AttributeTargets.Class, AllowMultiple=false, Inherited=false)]
+	public class ResolutionWeightAttribute : Attribute
+	{
+		public const int DefaultWeight = 100;
+
+		public ResolutionWeightAttribute(int weight)
+		{
+			this.Weight = weight;
+		}
+
+		public int Weight { get; private set; }
+
+		public static int ReadWeight(Type type)
+		{
+			var attr = type.GetCustomAttribute<ResolutionWeightAttribute>(false);
+			return attr != null ? attr.Weight : DefaultWeight;
+		}
+	}
+}
diff --git a/src/Umbraco.Core/Resolving/ResolverBase.cs b/src/Umbraco.Core/Resolving/ResolverBase.cs
new file mode 100644
index 0000000000..023eaecdc7
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/ResolverBase.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Threading;
+
+namespace Umbraco.Core.Resolving
+{
+	public abstract class ResolverBase<TResolver>
+	{
+		static TResolver _resolver;
+		static readonly ReaderWriterLockSlim ResolversLock = new ReaderWriterLockSlim();
+
+		public static TResolver Current
+		{
+			get
+			{
+				using (new ReadLock(ResolversLock))
+				{
+					if (_resolver == null)
+						throw new InvalidOperationException("Current has not been initialized. You must initialize Current before trying to read it.");
+					return _resolver;
+				}
+			}
+
+			set
+			{
+				using (new WriteLock(ResolversLock))
+				{
+					if (value == null)
+						throw new ArgumentNullException("value");
+					if (_resolver != null)
+						throw new InvalidOperationException("Current has already been initialized. It is not possible to re-initialize Current once it has been initialized.");
+					_resolver = value;
+				}
+			}
+		}
+	}
+}
diff --git a/src/Umbraco.Core/Resolving/SingleResolved.cs b/src/Umbraco.Core/Resolving/SingleResolved.cs
new file mode 100644
index 0000000000..065ad30898
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/SingleResolved.cs
@@ -0,0 +1,48 @@
+using System;
+
+namespace Umbraco.Core.Resolving
+{
+	public class SingleResolved<TResolved>
+	{
+		TResolved _resolved;
+		bool _canBeNull;
+
+		public SingleResolved()
+			: this(false)
+		{ }
+
+		public SingleResolved(TResolved value)
+			: this(false)
+		{
+			_resolved = value;
+		}
+
+		public SingleResolved(bool canBeNull)
+		{
+			_canBeNull = canBeNull;
+		}
+
+		public SingleResolved(TResolved value, bool canBeNull)
+		{
+			_resolved = value;
+			_canBeNull = canBeNull;
+		}
+
+		public TResolved Value
+		{
+			get
+			{
+				return _resolved;
+			}
+
+			set
+			{
+				Resolution.EnsureNotFrozen();
+
+				if (!_canBeNull && value == null)
+					throw new ArgumentNullException("value");
+				_resolved = value;
+			}
+		}
+	}
+}
diff --git a/src/Umbraco.Core/Resolving/SingleResolverBase.cs b/src/Umbraco.Core/Resolving/SingleResolverBase.cs
new file mode 100644
index 0000000000..7ca86b1cb3
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/SingleResolverBase.cs
@@ -0,0 +1,48 @@
+using System;
+
+namespace Umbraco.Core.Resolving
+{
+	public abstract class SingleResolverBase<TResolver, TResolved> : ResolverBase<TResolver>
+	{
+		TResolved _resolved;
+		bool _canBeNull;
+
+		protected SingleResolverBase()
+			: this(false)
+		{ }
+
+		protected SingleResolverBase(TResolved value)
+			: this(false)
+		{
+			_resolved = value;
+		}
+
+		protected SingleResolverBase(bool canBeNull)
+		{
+			_canBeNull = canBeNull;
+		}
+
+		protected SingleResolverBase(TResolved value, bool canBeNull)
+		{
+			_resolved = value;
+			_canBeNull = canBeNull;
+		}
+
+		protected TResolved Value
+		{
+			get
+			{
+				return _resolved;
+			}
+
+			set
+			{
+				Resolution.EnsureNotFrozen();
+
+				if (!_canBeNull && value == null)
+					throw new ArgumentNullException("value");
+				_resolved = value;
+			}
+		}
+	}
+}
diff --git a/src/Umbraco.Core/TypeExtensions.cs b/src/Umbraco.Core/TypeExtensions.cs
new file mode 100644
index 0000000000..4813f23243
--- /dev/null
+++ b/src/Umbraco.Core/TypeExtensions.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Umbraco.Core
+{
+	public static class TypeExtensions
+	{
+		public static IEnumerable<T> GetCustomAttributes<T>(this Type type, bool inherit)
+		{
+			return type.GetCustomAttributes(typeof(T), inherit).Cast<T>();
+		}
+
+		public static T GetCustomAttribute<T>(this Type type, bool inherit)
+		{
+			return type.GetCustomAttributes<T>(inherit).SingleOrDefault();
+		}
+	}
+}
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index 9c5101ff36..50e972ac1a 100644
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -45,6 +45,14 @@
       <Link>Properties\SolutionInfo.cs</Link>
     </Compile>
     <Compile Include="ApplicationContext.cs" />
+    <Compile Include="Resolving\ManyWeightedResolved.cs" />
+    <Compile Include="Resolving\ManyWeightedResolverBase.cs" />
+    <Compile Include="Resolving\Resolution.cs" />
+    <Compile Include="Resolving\ResolutionWeightAttribute.cs" />
+    <Compile Include="Resolving\ResolverBase.cs" />
+    <Compile Include="Resolving\SingleResolved.cs" />
+    <Compile Include="Resolving\SingleResolverBase.cs" />
+    <Compile Include="TypeExtensions.cs" />
     <Compile Include="UpgradeableReadLock.cs" />
     <Compile Include="ReadLock.cs" />
     <Compile Include="DelegateEqualityComparer.cs" />
@@ -63,6 +71,7 @@
       <Name>umbraco.businesslogic</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/src/Umbraco.Web/Routing/DocumentRequest.cs b/src/Umbraco.Web/Routing/DocumentRequest.cs
index 99b42b7263..d02d95c793 100644
--- a/src/Umbraco.Web/Routing/DocumentRequest.cs
+++ b/src/Umbraco.Web/Routing/DocumentRequest.cs
@@ -202,7 +202,7 @@ namespace Umbraco.Web.Routing
             // the first successful resolver, if any, will set this.Node, and may also set this.Template
             // some lookups may implement caching
             Trace.TraceInformation("{0}Begin resolvers", tracePrefix);
-			var resolvers = RoutingContext.RouteLookups.GetLookups();
+			var resolvers = RoutingContext.RequestDocumentResolversResolver.RequestDocumentResolvers;
         	resolvers.Any(resolver => resolver.TrySetDocument(this));
             Trace.TraceInformation("{0}End resolvers, {1}", tracePrefix, (this.HasNode ? "a document was found" : "no document was found"));
 
@@ -243,7 +243,8 @@ namespace Umbraco.Web.Routing
                     Trace.TraceInformation("{0}No document, try notFound lookup", tracePrefix);
 
                     // if it fails then give up, there isn't much more that we can do
-					if (RoutingContext.LookupNotFound == null || !RoutingContext.LookupNotFound.TrySetDocument(this))
+					var lastChance = RoutingContext.RequestDocumentResolversResolver.RequestDocumentLastChanceResolver;
+					if (lastChance == null || !lastChance.TrySetDocument(this))
                     {
                         Trace.TraceInformation("{0}Failed to find a document, give up", tracePrefix);
                         break;
@@ -446,7 +447,7 @@ namespace Umbraco.Web.Routing
                     redirectId = -1;
                 string redirectUrl = "#";
                 if (redirectId > 0)
-					redirectUrl = RoutingContext.NiceUrlResolver.GetNiceUrl(redirectId);
+					redirectUrl = RoutingContext.NiceUrlProvider.GetNiceUrl(redirectId);
                 if (redirectUrl != "#")
                     this.RedirectUrl = redirectUrl;
             }
diff --git a/src/Umbraco.Web/Routing/IRoutesCache.cs b/src/Umbraco.Web/Routing/IRoutesCache.cs
index 0f4a1044ec..0771fa556f 100644
--- a/src/Umbraco.Web/Routing/IRoutesCache.cs
+++ b/src/Umbraco.Web/Routing/IRoutesCache.cs
@@ -1,5 +1,13 @@
 namespace Umbraco.Web.Routing
 {
+	// this is a bi-directional cache that contains
+	// - nodeId to route (used for NiceUrl)
+	// - route to nodeId (used for inbound requests)
+	//
+	// a route is [rootId]/path/to/node
+	// where rootId is the id of the "site root" node
+	//
+
 	internal interface IRoutesCache
 	{
 		void Store(int nodeId, string route);
diff --git a/src/Umbraco.Web/NiceUrlResolver.cs b/src/Umbraco.Web/Routing/NiceUrlProvider.cs
similarity index 73%
rename from src/Umbraco.Web/NiceUrlResolver.cs
rename to src/Umbraco.Web/Routing/NiceUrlProvider.cs
index dec04e8a52..00a72b264c 100644
--- a/src/Umbraco.Web/NiceUrlResolver.cs
+++ b/src/Umbraco.Web/Routing/NiceUrlProvider.cs
@@ -10,14 +10,14 @@ using umbraco;
 using umbraco.IO;
 using umbraco.cms.businesslogic.web;
 
-namespace Umbraco.Web
+namespace Umbraco.Web.Routing
 {
 	/// <summary>
 	/// Resolves NiceUrls for a given node id
 	/// </summary>
-    internal class NiceUrlResolver
+    internal class NiceUrlProvider
     {
-		public NiceUrlResolver(ContentStore contentStore, UmbracoContext umbracoContext)
+		public NiceUrlProvider(ContentStore contentStore, UmbracoContext umbracoContext)
         {
             _umbracoContext = umbracoContext;
             _contentStore = contentStore;
@@ -31,11 +31,25 @@ namespace Umbraco.Web
 
 		#region GetNiceUrl
 
+		/// <summary>
+		/// Gets the nice url of a node.
+		/// </summary>
+		/// <param name="nodeId">The node id.</param>
+		/// <returns>The nice url for the node.</returns>
+		/// <remarks>The url is absolute or relative depending on the current url.</remarks>
 		public string GetNiceUrl(int nodeId)
 		{
 			return GetNiceUrl(nodeId, _umbracoContext.UmbracoUrl, false);
 		}
 
+		/// <summary>
+		/// Gets the nice url of a node.
+		/// </summary>
+		/// <param name="nodeId">The node id.</param>
+		/// <param name="current">The current url.</param>
+		/// <param name="absolute">A value indicating whether the url should be absolute in any case.</param>
+		/// <returns>The nice url for the node.</returns>
+		/// <remarks>The url is absolute or relative depending on the current url, unless absolute is true, and then it is always absolute.</remarks>
 		public string GetNiceUrl(int nodeId, Uri current, bool absolute)
         {
         	string path;
@@ -86,6 +100,19 @@ namespace Umbraco.Web
 			return AssembleUrl(domainUri, path, current, absolute).ToString();
 		}
 
+		/// <summary>
+		/// Gets the nice urls of a node.
+		/// </summary>
+		/// <param name="nodeId">The node id.</param>
+		/// <returns>An enumeration of all valid urls for the node.</returns>
+		/// <remarks>The urls are absolute. A node can have more than one url if more than one domain is defined.</remarks>
+		public IEnumerable<string> GetNiceUrls(int nodeId)
+		{
+			// fixme - to be implemented
+			// this is for editContent.aspx which currently has its own, highly buggy, implementation of NiceUrl...
+			throw new NotImplementedException();
+		}
+
 		Uri AssembleUrl(Uri domain, string path, Uri current, bool absolute)
 		{
 			Uri uri;
diff --git a/src/Umbraco.Web/Routing/RequestDocumentResolverWeightAttribute.cs b/src/Umbraco.Web/Routing/RequestDocumentResolverWeightAttribute.cs
deleted file mode 100644
index c76d7d5cf6..0000000000
--- a/src/Umbraco.Web/Routing/RequestDocumentResolverWeightAttribute.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-using System;
-
-namespace Umbraco.Web.Routing
-{
-    /// <summary>
-    /// Specifies the relative weight of an <c>IRequestDocumentResolver</c> implementation.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
-    internal class RequestDocumentResolverWeightAttribute : Attribute
-    {
-        /// <summary>
-        /// Gets the default weight.
-        /// </summary>
-        public const int DefaultWeight = 100;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RequestDocumentResolverWeightAttribute"/> class with the weight.
-        /// </summary>
-        /// <param name="weight">The weight.</param>
-        public RequestDocumentResolverWeightAttribute(int weight)
-            : base()
-        {
-            this.Weight = weight;
-        }
-
-        /// <summary>
-        /// Gets the weight.
-        /// </summary>
-        public int Weight { get; private set; }
-    }
-}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/RequestDocumentResolversResolver.cs b/src/Umbraco.Web/Routing/RequestDocumentResolversResolver.cs
new file mode 100644
index 0000000000..07735549e8
--- /dev/null
+++ b/src/Umbraco.Web/Routing/RequestDocumentResolversResolver.cs
@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+using Umbraco.Core;
+using Umbraco.Core.Resolving;
+
+namespace Umbraco.Web.Routing
+{
+	class RequestDocumentResolversResolver : ResolverBase<RequestDocumentResolversResolver>
+	{
+		internal RequestDocumentResolversResolver(IEnumerable<IRequestDocumentResolver> resolvers, IRequestDocumentLastChanceResolver lastChanceResolver)
+		{
+			_resolvers.AddRange(resolvers);
+			_lastChanceResolver.Value = lastChanceResolver;
+		}
+
+		#region LastChanceResolver
+
+		SingleResolved<IRequestDocumentLastChanceResolver> _lastChanceResolver = new SingleResolved<IRequestDocumentLastChanceResolver>(true);
+
+		public IRequestDocumentLastChanceResolver RequestDocumentLastChanceResolver
+		{
+			get { return _lastChanceResolver.Value; }
+			set { _lastChanceResolver.Value = value; }
+		}
+
+		#endregion
+
+		#region Resolvers
+
+		ManyWeightedResolved<IRequestDocumentResolver> _resolvers = new ManyWeightedResolved<IRequestDocumentResolver>();
+
+		public IEnumerable<IRequestDocumentResolver> RequestDocumentResolvers
+		{
+			get { return _resolvers.Values; }
+		}
+
+		public ManyWeightedResolved<IRequestDocumentResolver> RequestDocumentResolversResolution
+		{
+			get { return _resolvers; }
+		}
+
+		#endregion
+	}
+}
diff --git a/src/Umbraco.Web/Routing/ResolveByAlias.cs b/src/Umbraco.Web/Routing/ResolveByAlias.cs
index 3f41375309..321ef73bc0 100644
--- a/src/Umbraco.Web/Routing/ResolveByAlias.cs
+++ b/src/Umbraco.Web/Routing/ResolveByAlias.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Xml;
+using Umbraco.Core.Resolving;
 
 namespace Umbraco.Web.Routing
 {
@@ -10,7 +11,7 @@ namespace Umbraco.Web.Routing
     // at the moment aliases are not cleaned up into nice urls
     //
 
-    [RequestDocumentResolverWeight(50)]
+    [ResolutionWeight(50)]
     internal class ResolveByAlias : IRequestDocumentResolver
     {
 		static readonly TraceSource Trace = new TraceSource("ResolveByAlias");
diff --git a/src/Umbraco.Web/Routing/ResolveById.cs b/src/Umbraco.Web/Routing/ResolveById.cs
index 954152a7e2..0e2bfa74e1 100644
--- a/src/Umbraco.Web/Routing/ResolveById.cs
+++ b/src/Umbraco.Web/Routing/ResolveById.cs
@@ -1,13 +1,14 @@
 using System;
 using System.Diagnostics;
 using System.Xml;
+using Umbraco.Core.Resolving;
 
 namespace Umbraco.Web.Routing
 {
 
     // handles /1234 where 1234 is the id of a document
     //
-    [RequestDocumentResolverWeight(20)]
+    [ResolutionWeight(20)]
     internal class ResolveById : IRequestDocumentResolver
     {
 		static readonly TraceSource Trace = new TraceSource("ResolveById");
diff --git a/src/Umbraco.Web/Routing/ResolveByNiceUrl.cs b/src/Umbraco.Web/Routing/ResolveByNiceUrl.cs
index d5d7cb1b8f..4d8ebe0266 100644
--- a/src/Umbraco.Web/Routing/ResolveByNiceUrl.cs
+++ b/src/Umbraco.Web/Routing/ResolveByNiceUrl.cs
@@ -1,12 +1,13 @@
 using System.Diagnostics;
 using System.Xml;
+using Umbraco.Core.Resolving;
 
 namespace Umbraco.Web.Routing
 {
     // handles "/foo/bar" where "/foo/bar" is the path to a document
     //
 
-    [RequestDocumentResolverWeight(10)]
+    [ResolutionWeight(10)]
     internal class ResolveByNiceUrl : IRequestDocumentResolver
     {
 		static readonly TraceSource Trace = new TraceSource("ResolveByNiceUrl");
diff --git a/src/Umbraco.Web/Routing/ResolveByNiceUrlAndTemplate.cs b/src/Umbraco.Web/Routing/ResolveByNiceUrlAndTemplate.cs
index 1ccb043af6..a5a7473fd9 100644
--- a/src/Umbraco.Web/Routing/ResolveByNiceUrlAndTemplate.cs
+++ b/src/Umbraco.Web/Routing/ResolveByNiceUrlAndTemplate.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Xml;
+using Umbraco.Core.Resolving;
 using umbraco.cms.businesslogic.template;
 
 namespace Umbraco.Web.Routing
@@ -8,7 +9,7 @@ namespace Umbraco.Web.Routing
     // handles /foo/bar/<template> where <template> is a valid template alias
     // and /foo/bar the nice url of a document
     //
-    [RequestDocumentResolverWeight(30)]
+    [ResolutionWeight(30)]
     internal class ResolveByNiceUrlAndTemplate : ResolveByNiceUrl, IRequestDocumentResolver
     {
 		static readonly TraceSource Trace = new TraceSource("ResolveByNiceUrlAndTemplate");		
diff --git a/src/Umbraco.Web/Routing/ResolveByProfile.cs b/src/Umbraco.Web/Routing/ResolveByProfile.cs
index dc5f4f7ff2..afd624e8d5 100644
--- a/src/Umbraco.Web/Routing/ResolveByProfile.cs
+++ b/src/Umbraco.Web/Routing/ResolveByProfile.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Xml;
+using Umbraco.Core.Resolving;
 using umbraco;
 
 namespace Umbraco.Web.Routing
@@ -11,7 +12,7 @@ namespace Umbraco.Web.Routing
     //
     // we're keeping it here only for backward compatibility.
     //
-    [RequestDocumentResolverWeight(40)]
+    [ResolutionWeight(40)]
     internal class ResolveByProfile : ResolveByNiceUrl, IRequestDocumentResolver
     {
 		static readonly TraceSource Trace = new TraceSource("ResolveByProfile");		
diff --git a/src/Umbraco.Web/Routing/RouteLookups.cs b/src/Umbraco.Web/Routing/RouteLookups.cs
deleted file mode 100644
index 6abaa2e7f4..0000000000
--- a/src/Umbraco.Web/Routing/RouteLookups.cs
+++ /dev/null
@@ -1,111 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using Umbraco.Core;
-
-namespace Umbraco.Web.Routing
-{
-	// fixme - this class is broken in various ways
-	// + we can't reproduce that sort of code for everything we need to discover
-
-	/// <summary>
-	/// Represents a collection of ILookup used for routing that are registered in the application
-	/// </summary>
-	internal class RouteLookups
-	{
-		private static readonly List<IRequestDocumentResolver> Lookups = new List<IRequestDocumentResolver>();
-		private static readonly ReaderWriterLockSlim Lock = new ReaderWriterLockSlim();
-
-		/// <summary>
-		/// Singleton accessor
-		/// </summary>
-		public static RouteLookups Current { get; internal set; }
-
-		internal RouteLookups(IEnumerable<IRequestDocumentResolver> lookups)
-		{
-			Lookups.AddRange(SortByWeight(lookups));
-		}
-
-		/// <summary>
-		/// Returns all of the lookups
-		/// </summary>
-		/// <returns></returns>
-		public IEnumerable<IRequestDocumentResolver> GetLookups()
-		{
-			// FIXME - and then, we return a non-thread-safe collection ... WTF?
-
-			return Lookups;
-		} 
-
-		/// <summary>
-		/// Removes an ILookup based on the specified Type
-		/// </summary>
-		/// <typeparam name="T"></typeparam>
-		public void RemoveLookup<T>()
-			where T : IRequestDocumentResolver
-		{
-			using (new WriteLock(Lock))
-			{
-				Lookups.Remove(Lookups.SingleOrDefault(x => x is T));	
-			}			
-		}
-
-	
-		/// <summary>
-		/// Adds a new lookup to the end of the list
-		/// </summary>
-		/// <param name="lookup"></param>
-		public void AddLookup(IRequestDocumentResolver lookup)
-		{
-			using (var l = new UpgradeableReadLock(Lock))
-			{
-				if (CheckExists(lookup))
-					throw new InvalidOperationException(string.Format("The lookup type \"{0}\" already exists in the lookup collection.", lookup));
-				l.UpgradeToWriteLock();
-				Lookups.Add(lookup);
-			}
-		}
-
-		/// <summary>
-		/// Inserts a lookup at the specified index
-		/// </summary>
-		/// <param name="index"></param>
-		/// <param name="lookup"></param>
-		public void InsertLookup(int index, IRequestDocumentResolver lookup)
-		{
-			if (CheckExists(lookup))
-				throw new InvalidOperationException("The lookup type " + lookup + " already exists in the lookup collection");
-			
-			using (new WriteLock(Lock))
-			{
-				Lookups.Insert(index, lookup);
-			}			
-		}
-
-		/// <summary>
-		/// checks if a lookup already exists by type
-		/// </summary>
-		/// <param name="lookup"></param>
-		/// <returns></returns>
-		private static bool CheckExists(IRequestDocumentResolver lookup)
-		{
-			return Lookups.Any(x => x.GetType() == lookup.GetType());
-		}
-
-		/// <summary>
-		/// Sorts the ILookups in the list based on an attribute weight if one is specified
-		/// </summary>
-		/// <param name="lookups"></param>
-		/// <returns></returns>
-		private static IEnumerable<IRequestDocumentResolver> SortByWeight(IEnumerable<IRequestDocumentResolver> lookups)
-		{
-			return lookups.OrderBy(x =>
-				{
-					var attribute = x.GetType().GetCustomAttributes(true).OfType<RequestDocumentResolverWeightAttribute>().SingleOrDefault();
-					return attribute == null ? RequestDocumentResolverWeightAttribute.DefaultWeight : attribute.Weight;
-				}).ToList();
-		}
-
-	}
-}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/RoutesCache.cs b/src/Umbraco.Web/Routing/RoutesCache.cs
deleted file mode 100644
index e46fa9681c..0000000000
--- a/src/Umbraco.Web/Routing/RoutesCache.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-using System;
-
-namespace Umbraco.Web.Routing
-{
-	// this is a bi-directional cache that contains
-	// - nodeId to route (used for NiceUrl)
-	// - route to nodeId (used for inbound requests)
-	//
-	// a route is [rootId]/path/to/node
-	// where rootId is the id of the "site root" node
-	//
-	internal class RoutesCache
-	{
-		private static readonly RoutesCache Instance = new RoutesCache();
-		private static IRoutesCache _provider;
-
-		/// <summary>
-		/// public contructor assigns the DefaultRoutesCache as the default provider
-		/// </summary>
-		public RoutesCache()
-			:this(null)
-		{			
-		}
-
-		/// <summary>
-		/// Constructor sets a custom provider if specified
-		/// </summary>
-		/// <param name="provider"></param>
-		internal RoutesCache(IRoutesCache provider)
-		{
-			_provider = provider ?? new DefaultRoutesCache();
-		}
-
-		/// <summary>
-		/// Set the routes cache provider
-		/// </summary>
-		/// <param name="provider"></param>
-		public static void SetProvider(IRoutesCache provider)
-		{
-			if (provider == null) throw new ArgumentNullException("provider");
-			_provider = provider;
-		}
-
-		/// <summary>
-		/// Singleton accessor
-		/// </summary>
-		public static RoutesCache Current
-		{
-			get { return Instance; }
-		}
-
-		/// <summary>
-		/// Get the current provider
-		/// </summary>
-		/// <returns></returns>
-		public IRoutesCache GetProvider()
-		{
-			return _provider;
-		}
-	}
-}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/RoutesCacheResolver.cs b/src/Umbraco.Web/Routing/RoutesCacheResolver.cs
new file mode 100644
index 0000000000..98d1114866
--- /dev/null
+++ b/src/Umbraco.Web/Routing/RoutesCacheResolver.cs
@@ -0,0 +1,18 @@
+using System;
+using Umbraco.Core.Resolving;
+
+namespace Umbraco.Web.Routing
+{
+	class RoutesCacheResolver : SingleResolverBase<RoutesCacheResolver, IRoutesCache>
+	{
+		internal RoutesCacheResolver(IRoutesCache routesCache)
+			: base(routesCache)
+		{ }
+
+		public IRoutesCache RoutesCache
+		{
+			get { return this.Value; }
+			set { this.Value = value; }
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/RoutingContext.cs b/src/Umbraco.Web/Routing/RoutingContext.cs
index dc75d3451f..33ecdbcd42 100644
--- a/src/Umbraco.Web/Routing/RoutingContext.cs
+++ b/src/Umbraco.Web/Routing/RoutingContext.cs
@@ -12,22 +12,19 @@ namespace Umbraco.Web.Routing
     {
         public RoutingContext(
 			UmbracoContext umbracoContext,
-            RouteLookups lookups,
-            IRequestDocumentLastChanceResolver lookupNotFound,
+			RequestDocumentResolversResolver requestDocumentResolversResolver,
             ContentStore contentStore,
-			NiceUrlResolver niceUrlResolver)
+			NiceUrlProvider niceUrlResolver)
         {
-        	UmbracoContext = umbracoContext;
-        	RouteLookups = lookups;
-            LookupNotFound = lookupNotFound;
-            ContentStore = contentStore;
-        	NiceUrlResolver = niceUrlResolver;
+        	this.UmbracoContext = umbracoContext;
+			this.RequestDocumentResolversResolver = requestDocumentResolversResolver;
+            this.ContentStore = contentStore;
+        	this.NiceUrlProvider = niceUrlResolver;
         }
 
 		public UmbracoContext UmbracoContext { get; private set; }
-		public RouteLookups RouteLookups { get; private set; }
-    	public IRequestDocumentLastChanceResolver LookupNotFound { get; private set; }
+		public RequestDocumentResolversResolver RequestDocumentResolversResolver { get; private set; }
         public ContentStore ContentStore { get; private set; }
-		public NiceUrlResolver NiceUrlResolver { get; private set; }
+		public NiceUrlProvider NiceUrlProvider { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Web/Umbraco.Web.csproj b/src/Umbraco.Web/Umbraco.Web.csproj
index 7b97dc8436..73874de594 100644
--- a/src/Umbraco.Web/Umbraco.Web.csproj
+++ b/src/Umbraco.Web/Umbraco.Web.csproj
@@ -240,10 +240,10 @@
     <Compile Include="ContentStore.cs" />
     <Compile Include="LegacyRequestInitializer.cs" />
     <Compile Include="Mvc\ControllerExtensions.cs" />
-    <Compile Include="NiceUrlResolver.cs" />
+    <Compile Include="Routing\NiceUrlProvider.cs" />
     <Compile Include="PluginResolverExtensions.cs" />
     <Compile Include="Routing\Domains.cs" />
-    <Compile Include="Routing\RouteLookups.cs" />
+    <Compile Include="Routing\RequestDocumentResolversResolver.cs" />
     <Compile Include="Routing\DocumentRequest.cs" />
     <Compile Include="Routing\IRequestDocumentResolver.cs" />
     <Compile Include="Routing\IRequestDocumentLastChanceResolver.cs" />
@@ -254,9 +254,8 @@
     <Compile Include="Routing\ResolveByNiceUrlAndTemplate.cs" />
     <Compile Include="Routing\ResolveByProfile.cs" />
     <Compile Include="Routing\ResolveLastChance.cs" />
-    <Compile Include="Routing\RequestDocumentResolverWeightAttribute.cs" />
     <Compile Include="Routing\DefaultRoutesCache.cs" />
-    <Compile Include="Routing\RoutesCache.cs" />
+    <Compile Include="Routing\RoutesCacheResolver.cs" />
     <Compile Include="Routing\RoutingContext.cs" />
     <Compile Include="umbraco.presentation\EnsureSystemPathsApplicationStartupHandler.cs" />
     <Compile Include="umbraco.presentation\install\steps\database.ascx.cs">
@@ -1814,7 +1813,9 @@
     <Content Include="umbraco.presentation\umbraco\dialogs\Preview.aspx" />
     <Content Include="umbraco.presentation\umbraco\controls\passwordChanger.ascx" />
     <Content Include="umbraco.presentation\umbraco\controls\ProgressBar.ascx" />
-    <Content Include="umbraco.presentation\umbraco\controls\ContentTypeControlNew.ascx" />
+    <Content Include="umbraco.presentation\umbraco\controls\ContentTypeControlNew.ascx">
+      <SubType>ASPXCodeBehind</SubType>
+    </Content>
     <Content Include="umbraco.presentation\umbraco\controls\GenericProperties\GenericProperty.ascx" />
     <Content Include="umbraco.presentation\umbraco\create\DLRScripting.ascx" />
     <Content Include="umbraco.presentation\umbraco\controls\Images\ImageViewer.ascx" />
diff --git a/src/Umbraco.Web/UmbracoApplication.cs b/src/Umbraco.Web/UmbracoApplication.cs
index 5febadc78a..53447f4698 100644
--- a/src/Umbraco.Web/UmbracoApplication.cs
+++ b/src/Umbraco.Web/UmbracoApplication.cs
@@ -35,8 +35,11 @@ namespace Umbraco.Web
 					IsReady = true	// fixme
 				};
 
-			//create the route lookups singleton
-			RouteLookups.Current = new RouteLookups(ApplicationContext.Current.Plugins.ResolveLookups());
+			// create the resolvers
+			RequestDocumentResolversResolver.Current = new RequestDocumentResolversResolver(ApplicationContext.Current.Plugins.ResolveLookups(), new ResolveLastChance());
+			RoutesCacheResolver.Current = new RoutesCacheResolver(new DefaultRoutesCache());
+
+			Umbraco.Core.Resolving.Resolution.Freeze();
 
 			Trace.TraceInformation("AppDomain is initialized");
 		}
diff --git a/src/Umbraco.Web/UmbracoContext.cs b/src/Umbraco.Web/UmbracoContext.cs
index 46f7f38aa5..806ef7a438 100644
--- a/src/Umbraco.Web/UmbracoContext.cs
+++ b/src/Umbraco.Web/UmbracoContext.cs
@@ -132,7 +132,7 @@ namespace Umbraco.Web
 			set
 			{
 				_requestUrl = value;
-				this.UmbracoUrl = NiceUrlResolver.UriToUmbraco(_requestUrl);
+				this.UmbracoUrl = NiceUrlProvider.UriToUmbraco(_requestUrl);
 			}
 		}
 
diff --git a/src/Umbraco.Web/UmbracoModule.cs b/src/Umbraco.Web/UmbracoModule.cs
index 3881f26b53..49a8f2cc67 100644
--- a/src/Umbraco.Web/UmbracoModule.cs
+++ b/src/Umbraco.Web/UmbracoModule.cs
@@ -45,7 +45,7 @@ namespace Umbraco.Web
             var umbracoContext = new UmbracoContext(
 				new HttpContextWrapper(httpContext), 
 				ApplicationContext.Current,
-				 RoutesCache.Current.GetProvider());
+				 RoutesCacheResolver.Current.RoutesCache);
             UmbracoContext.Current = umbracoContext;
 
 			// NO!
@@ -54,12 +54,11 @@ namespace Umbraco.Web
             //create a content store
             var contentStore = new ContentStore(umbracoContext);            
             //create the nice urls
-            var niceUrls = new NiceUrlResolver(contentStore, umbracoContext);
+            var niceUrls = new NiceUrlProvider(contentStore, umbracoContext);
             //create the RoutingContext (one per http request)
         	var routingContext = new RoutingContext(
         		umbracoContext,
-        		RouteLookups.Current,
-        		new ResolveLastChance(),
+        		RequestDocumentResolversResolver.Current,
         		contentStore,
         		niceUrls);
 			// NOT HERE BUT SEE **THERE** BELOW
diff --git a/src/Umbraco.Web/umbraco.presentation/library.cs b/src/Umbraco.Web/umbraco.presentation/library.cs
index d1df067bae..e899524309 100644
--- a/src/Umbraco.Web/umbraco.presentation/library.cs
+++ b/src/Umbraco.Web/umbraco.presentation/library.cs
@@ -355,10 +355,8 @@ namespace umbraco
         /// <returns>String with a friendly url from a node</returns>
         public static string NiceUrl(int nodeID)
         {
-			// OK, how are we supposed to retrieve the NiceUrlResolver from here,
-			// bearing in mind that we don't want to instanciate a resolver + content store + ...
-			// for every NiceUrl call ?!
-			return Umbraco.Core.UmbracoContainer.Get<Umbraco.Web.Routing.NiceUrls>().GetNiceUrl(nodeID);
+			var niceUrlsProvider = Umbraco.Web.UmbracoContext.Current.DocumentRequest.RoutingContext.NiceUrlProvider;
+			return niceUrlsProvider.GetNiceUrl(nodeID);
         }
 
         /// <summary>
@@ -380,10 +378,8 @@ namespace umbraco
         /// <returns>String with a friendly url with full domain from a node</returns>
         public static string NiceUrlWithDomain(int nodeID)
         {
-			// OK, how are we supposed to retrieve the NiceUrlResolver from here,
-			// bearing in mind that we don't want to instanciate a resolver + content store + ...
-			// for every NiceUrl call ?!
-			return Umbraco.Core.UmbracoContainer.Get<Umbraco.Web.Routing.NiceUrls>().GetNiceUrl(nodeID, Umbraco.Web.UmbracoContext.Current.UmbracoUrl, true);
+			var niceUrlsProvider = Umbraco.Web.UmbracoContext.Current.DocumentRequest.RoutingContext.NiceUrlProvider;
+			return niceUrlsProvider.GetNiceUrl(nodeID, Umbraco.Web.UmbracoContext.Current.UmbracoUrl, true);
         }
 
 

From fec2e0eb6e6287fd49d25bdda53db10f373fdec7 Mon Sep 17 00:00:00 2001
From: sgay <unknown@kiln.example.com>
Date: Thu, 26 Jul 2012 12:56:41 -0200
Subject: [PATCH 2/3] rename routing 'resolvers' to 'lookups'

---
 src/Umbraco.Web/PluginResolverExtensions.cs | 10 +++----
 src/Umbraco.Web/Routing/DocumentRequest.cs  | 30 ++++++++++-----------
 src/Umbraco.Web/Routing/RoutingContext.cs   |  6 ++---
 src/Umbraco.Web/Umbraco.Web.csproj          | 18 ++++++-------
 src/Umbraco.Web/UmbracoApplication.cs       |  2 +-
 src/Umbraco.Web/UmbracoModule.cs            |  6 ++---
 6 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/src/Umbraco.Web/PluginResolverExtensions.cs b/src/Umbraco.Web/PluginResolverExtensions.cs
index 3d4eaff11a..d480e3ec91 100644
--- a/src/Umbraco.Web/PluginResolverExtensions.cs
+++ b/src/Umbraco.Web/PluginResolverExtensions.cs
@@ -13,7 +13,7 @@ namespace Umbraco.Web
 	public static class PluginResolverExtensions
 	{
 
-		private static volatile IEnumerable<IRequestDocumentResolver> _lookups;
+		private static volatile IEnumerable<IDocumentLookup> _lookups;
 		private static readonly object Locker = new object();
 
 		/// <summary>
@@ -21,7 +21,7 @@ namespace Umbraco.Web
 		/// </summary>
 		/// <param name="plugins"></param>
 		/// <returns></returns>
-		internal static IEnumerable<IRequestDocumentResolver> ResolveLookups(this PluginResolver plugins)
+		internal static IEnumerable<IDocumentLookup> ResolveLookups(this PluginResolver plugins)
 		{
 			if (_lookups == null)
 			{
@@ -29,13 +29,13 @@ namespace Umbraco.Web
 				{
 					if (_lookups == null)
 					{
-						var lookupTypes = TypeFinder.FindClassesOfType<IRequestDocumentResolver>();
-						var lookups = new List<IRequestDocumentResolver>();
+						var lookupTypes = TypeFinder.FindClassesOfType<IDocumentLookup>();
+						var lookups = new List<IDocumentLookup>();
 						foreach (var l in lookupTypes)
 						{
 							try
 							{
-								var typeInstance = Activator.CreateInstance(l) as IRequestDocumentResolver;
+								var typeInstance = Activator.CreateInstance(l) as IDocumentLookup;
 								lookups.Add(typeInstance);
 							}
 							catch (Exception ex)
diff --git a/src/Umbraco.Web/Routing/DocumentRequest.cs b/src/Umbraco.Web/Routing/DocumentRequest.cs
index d02d95c793..d9b450b2a5 100644
--- a/src/Umbraco.Web/Routing/DocumentRequest.cs
+++ b/src/Umbraco.Web/Routing/DocumentRequest.cs
@@ -140,15 +140,15 @@ namespace Umbraco.Web.Routing
 
         #endregion
 
-        #region Resolve
+        #region Lookup
 
         /// <summary>
         /// Determines the site root (if any) matching the http request.
         /// </summary>        
         /// <returns>A value indicating whether a domain was found.</returns>
-		public bool ResolveDomain()
+		public bool LookupDomain()
         {
-            const string tracePrefix = "ResolveDomain: ";
+			const string tracePrefix = "LookupDomain: ";
 
             // note - we are not handling schemes nor ports here.
 
@@ -193,17 +193,17 @@ namespace Umbraco.Web.Routing
         /// Determines the Umbraco document (if any) matching the http request.
         /// </summary>
         /// <returns>A value indicating whether a document and template nave been found.</returns>
-        public bool ResolveDocument()
+        public bool LookupDocument()
         {
-            const string tracePrefix = "ResolveDocument: ";
+			const string tracePrefix = "LookupDocument: ";
             Trace.TraceInformation("{0}Path=\"{1}\"", tracePrefix, this.Uri.AbsolutePath);
 
             // look for the document
             // the first successful resolver, if any, will set this.Node, and may also set this.Template
             // some lookups may implement caching
             Trace.TraceInformation("{0}Begin resolvers", tracePrefix);
-			var resolvers = RoutingContext.RequestDocumentResolversResolver.RequestDocumentResolvers;
-        	resolvers.Any(resolver => resolver.TrySetDocument(this));
+			var lookups = RoutingContext.DocumentLookupsResolver.DocumentLookups;
+        	lookups.Any(lookup => lookup.TrySetDocument(this));
             Trace.TraceInformation("{0}End resolvers, {1}", tracePrefix, (this.HasNode ? "a document was found" : "no document was found"));
 
             // fixme - not handling umbracoRedirect
@@ -211,7 +211,7 @@ namespace Umbraco.Web.Routing
             // so after ResolveDocument2() => docreq.IsRedirect => handled by the module!
 
             // handle not-found, redirects, access, template
-            ResolveDocument2();
+            LookupDocument2();
 
             // handle umbracoRedirect (moved from umbraco.page)
             FollowRedirect();
@@ -224,9 +224,9 @@ namespace Umbraco.Web.Routing
         /// Performs the document resolution second pass.
         /// </summary>
         /// <remarks>The second pass consists in handling "not found", internal redirects, access validation, and template.</remarks>
-        void ResolveDocument2()
+        void LookupDocument2()
         {
-            const string tracePrefix = "ResolveDocument2: ";
+			const string tracePrefix = "LookupDocument2: ";
 
             // handle "not found", follow internal redirects, validate access, template
             // because these might loop, we have to have some sort of infinite loop detection 
@@ -240,10 +240,10 @@ namespace Umbraco.Web.Routing
                 if (!this.HasNode)
                 {
                     this.Is404 = true;
-                    Trace.TraceInformation("{0}No document, try notFound lookup", tracePrefix);
+                    Trace.TraceInformation("{0}No document, try last chance lookup", tracePrefix);
 
                     // if it fails then give up, there isn't much more that we can do
-					var lastChance = RoutingContext.RequestDocumentResolversResolver.RequestDocumentLastChanceResolver;
+					var lastChance = RoutingContext.DocumentLookupsResolver.DocumentLastChanceLookup;
 					if (lastChance == null || !lastChance.TrySetDocument(this))
                     {
                         Trace.TraceInformation("{0}Failed to find a document, give up", tracePrefix);
@@ -267,7 +267,7 @@ namespace Umbraco.Web.Routing
 
                 // resolve template
                 if (this.HasNode)
-                    ResolveTemplate();
+                    LookupTemplate();
 
                 // loop while we don't have page, ie the redirect or access
                 // got us to nowhere and now we need to run the notFoundLookup again
@@ -384,9 +384,9 @@ namespace Umbraco.Web.Routing
         /// <summary>
         /// Resolves a template for the current node.
         /// </summary>
-        void ResolveTemplate()
+        void LookupTemplate()
         {
-            const string tracePrefix = "ResolveTemplate: ";
+			const string tracePrefix = "LookupTemplate: ";
 
             if (this.Node == null)
                 throw new InvalidOperationException("There is no node.");
diff --git a/src/Umbraco.Web/Routing/RoutingContext.cs b/src/Umbraco.Web/Routing/RoutingContext.cs
index 33ecdbcd42..19aa35fea8 100644
--- a/src/Umbraco.Web/Routing/RoutingContext.cs
+++ b/src/Umbraco.Web/Routing/RoutingContext.cs
@@ -12,18 +12,18 @@ namespace Umbraco.Web.Routing
     {
         public RoutingContext(
 			UmbracoContext umbracoContext,
-			RequestDocumentResolversResolver requestDocumentResolversResolver,
+			DocumentLookupsResolver documentLookupsResolver,
             ContentStore contentStore,
 			NiceUrlProvider niceUrlResolver)
         {
         	this.UmbracoContext = umbracoContext;
-			this.RequestDocumentResolversResolver = requestDocumentResolversResolver;
+			this.DocumentLookupsResolver = documentLookupsResolver;
             this.ContentStore = contentStore;
         	this.NiceUrlProvider = niceUrlResolver;
         }
 
 		public UmbracoContext UmbracoContext { get; private set; }
-		public RequestDocumentResolversResolver RequestDocumentResolversResolver { get; private set; }
+		public DocumentLookupsResolver DocumentLookupsResolver { get; private set; }
         public ContentStore ContentStore { get; private set; }
 		public NiceUrlProvider NiceUrlProvider { get; private set; }
     }
diff --git a/src/Umbraco.Web/Umbraco.Web.csproj b/src/Umbraco.Web/Umbraco.Web.csproj
index 73874de594..1488af6b52 100644
--- a/src/Umbraco.Web/Umbraco.Web.csproj
+++ b/src/Umbraco.Web/Umbraco.Web.csproj
@@ -243,17 +243,17 @@
     <Compile Include="Routing\NiceUrlProvider.cs" />
     <Compile Include="PluginResolverExtensions.cs" />
     <Compile Include="Routing\Domains.cs" />
-    <Compile Include="Routing\RequestDocumentResolversResolver.cs" />
+    <Compile Include="Routing\DocumentLookupsResolver.cs" />
     <Compile Include="Routing\DocumentRequest.cs" />
-    <Compile Include="Routing\IRequestDocumentResolver.cs" />
-    <Compile Include="Routing\IRequestDocumentLastChanceResolver.cs" />
+    <Compile Include="Routing\IDocumentLookup.cs" />
+    <Compile Include="Routing\IDocumentLastChanceLookup.cs" />
     <Compile Include="Routing\IRoutesCache.cs" />
-    <Compile Include="Routing\ResolveByAlias.cs" />
-    <Compile Include="Routing\ResolveById.cs" />
-    <Compile Include="Routing\ResolveByNiceUrl.cs" />
-    <Compile Include="Routing\ResolveByNiceUrlAndTemplate.cs" />
-    <Compile Include="Routing\ResolveByProfile.cs" />
-    <Compile Include="Routing\ResolveLastChance.cs" />
+    <Compile Include="Routing\LookupByAlias.cs" />
+    <Compile Include="Routing\LookupById.cs" />
+    <Compile Include="Routing\LookupByNiceUrl.cs" />
+    <Compile Include="Routing\LookupByNiceUrlAndTemplate.cs" />
+    <Compile Include="Routing\LookupByProfile.cs" />
+    <Compile Include="Routing\DefaultLastChanceLookup.cs" />
     <Compile Include="Routing\DefaultRoutesCache.cs" />
     <Compile Include="Routing\RoutesCacheResolver.cs" />
     <Compile Include="Routing\RoutingContext.cs" />
diff --git a/src/Umbraco.Web/UmbracoApplication.cs b/src/Umbraco.Web/UmbracoApplication.cs
index 53447f4698..dfa0f90248 100644
--- a/src/Umbraco.Web/UmbracoApplication.cs
+++ b/src/Umbraco.Web/UmbracoApplication.cs
@@ -36,7 +36,7 @@ namespace Umbraco.Web
 				};
 
 			// create the resolvers
-			RequestDocumentResolversResolver.Current = new RequestDocumentResolversResolver(ApplicationContext.Current.Plugins.ResolveLookups(), new ResolveLastChance());
+			DocumentLookupsResolver.Current = new DocumentLookupsResolver(ApplicationContext.Current.Plugins.ResolveLookups(), new DefaultLastChanceLookup());
 			RoutesCacheResolver.Current = new RoutesCacheResolver(new DefaultRoutesCache());
 
 			Umbraco.Core.Resolving.Resolution.Freeze();
diff --git a/src/Umbraco.Web/UmbracoModule.cs b/src/Umbraco.Web/UmbracoModule.cs
index 49a8f2cc67..3505f497bb 100644
--- a/src/Umbraco.Web/UmbracoModule.cs
+++ b/src/Umbraco.Web/UmbracoModule.cs
@@ -58,7 +58,7 @@ namespace Umbraco.Web
             //create the RoutingContext (one per http request)
         	var routingContext = new RoutingContext(
         		umbracoContext,
-        		RequestDocumentResolversResolver.Current,
+        		DocumentLookupsResolver.Current,
         		contentStore,
         		niceUrls);
 			// NOT HERE BUT SEE **THERE** BELOW
@@ -106,11 +106,11 @@ namespace Umbraco.Web
 
 			//**THERE** we should create the doc request
 			// before, we're not sure we handling a doc request
-			docreq.ResolveDomain();
+			docreq.LookupDomain();
             if (docreq.IsRedirect)
                 httpContext.Response.Redirect(docreq.RedirectUrl, true);
             Thread.CurrentThread.CurrentUICulture = Thread.CurrentThread.CurrentCulture = docreq.Culture;
-            docreq.ResolveDocument();
+            docreq.LookupDocument();
             if (docreq.IsRedirect)
                 httpContext.Response.Redirect(docreq.RedirectUrl, true);
 

From 53f6577b320d90637eb69bff9cf3f977ed6f0bbf Mon Sep 17 00:00:00 2001
From: sgay <unknown@kiln.example.com>
Date: Thu, 26 Jul 2012 14:21:47 -0200
Subject: [PATCH 3/3] write xml doc

---
 src/Umbraco.Web/Routing/DefaultRoutesCache.cs | 43 ++++++--
 src/Umbraco.Web/Routing/DocumentRequest.cs    |  2 +-
 src/Umbraco.Web/Routing/Domains.cs            | 53 +++++++++-
 src/Umbraco.Web/Routing/IRoutesCache.cs       | 41 ++++++--
 src/Umbraco.Web/Routing/NiceUrlProvider.cs    | 97 ++++++++++++++++---
 .../Routing/RoutesCacheResolver.cs            | 10 ++
 src/Umbraco.Web/Routing/RoutingContext.cs     | 25 ++++-
 7 files changed, 239 insertions(+), 32 deletions(-)

diff --git a/src/Umbraco.Web/Routing/DefaultRoutesCache.cs b/src/Umbraco.Web/Routing/DefaultRoutesCache.cs
index b4daefaea2..55a2c08e75 100644
--- a/src/Umbraco.Web/Routing/DefaultRoutesCache.cs
+++ b/src/Umbraco.Web/Routing/DefaultRoutesCache.cs
@@ -6,7 +6,7 @@ using Umbraco.Core;
 namespace Umbraco.Web.Routing
 {
 	/// <summary>
-	/// The default implementation of IRoutesCache
+	/// Provides a default implementation of <see cref="IRoutesCache"/>.
 	/// </summary>
 	internal class DefaultRoutesCache : IRoutesCache
 	{
@@ -14,23 +14,31 @@ namespace Umbraco.Web.Routing
 		private Dictionary<int, string> _routes;
         private Dictionary<string, int> _nodeIds;
 
+		/// <summary>
+		/// Initializes a new instance of the <see cref="DefaultRoutesCache"/> class.
+		/// </summary>
         public DefaultRoutesCache()
         {
             Clear();
 
-            // here we should register handlers to clear the cache when content changes
-            // at the moment this is done by library, which clears everything when content changed
-            //
-            // but really, we should do some partial refreshes!
-            // otherwise, we could even cache 404 errors...
-			//
-			// these are the two events used by library in legacy code...
-			// is it enough?
+			//FIXME:
 			//
+            // here we must register handlers to clear the cache when content changes
+			// this was done by presentation.library, which cleared everything when content changed
+            // but really, we should do some partial refreshes
+
+			// these are the two events that were used by presentation.library
+			// are they enough?
+
 			global::umbraco.content.AfterRefreshContent += (sender, e) => Clear();
 			global::umbraco.content.AfterUpdateDocumentCache += (sender, e) => Clear();
         }
 
+		/// <summary>
+		/// Stores a route for a node.
+		/// </summary>
+		/// <param name="nodeId">The node identified.</param>
+		/// <param name="route">The route.</param>
         public void Store(int nodeId, string route)
         {
             using (new WriteLock(_lock))
@@ -40,6 +48,11 @@ namespace Umbraco.Web.Routing
             }
         }
 
+		/// <summary>
+		/// Gets a route for a node.
+		/// </summary>
+		/// <param name="nodeId">The node identifier.</param>
+		/// <returns>The route for the node, else null.</returns>
         public string GetRoute(int nodeId)
         {
             lock (new ReadLock(_lock))
@@ -48,6 +61,11 @@ namespace Umbraco.Web.Routing
             }
         }
 
+		/// <summary>
+		/// Gets a node for a route.
+		/// </summary>
+		/// <param name="route">The route.</param>
+		/// <returns>The node identified for the route, else zero.</returns>
         public int GetNodeId(string route)
         {
             using (new ReadLock(_lock))
@@ -56,6 +74,10 @@ namespace Umbraco.Web.Routing
             }
         }
 
+		/// <summary>
+		/// Clears the route for a node.
+		/// </summary>
+		/// <param name="nodeId">The node identifier.</param>
         public void ClearNode(int nodeId)
         {
             using (var lck = new UpgradeableReadLock(_lock))
@@ -69,6 +91,9 @@ namespace Umbraco.Web.Routing
             }
         }
 
+		/// <summary>
+		/// Clears all routes.
+		/// </summary>
         public void Clear()
         {
             using (new WriteLock(_lock))
diff --git a/src/Umbraco.Web/Routing/DocumentRequest.cs b/src/Umbraco.Web/Routing/DocumentRequest.cs
index d9b450b2a5..bc25fc0fbc 100644
--- a/src/Umbraco.Web/Routing/DocumentRequest.cs
+++ b/src/Umbraco.Web/Routing/DocumentRequest.cs
@@ -155,7 +155,7 @@ namespace Umbraco.Web.Routing
             Trace.TraceInformation("{0}Uri=\"{1}\"", tracePrefix, this.Uri);
 
             // try to find a domain matching the current request
-			var domainAndUri = Domains.ApplicableDomains(Domain.GetDomains(), RoutingContext.UmbracoContext.UmbracoUrl, false);
+			var domainAndUri = Domains.DomainMatch(Domain.GetDomains(), RoutingContext.UmbracoContext.UmbracoUrl, false);
 
             // handle domain
 			if (domainAndUri != null)
diff --git a/src/Umbraco.Web/Routing/Domains.cs b/src/Umbraco.Web/Routing/Domains.cs
index 01b5def78a..72454c3718 100644
--- a/src/Umbraco.Web/Routing/Domains.cs
+++ b/src/Umbraco.Web/Routing/Domains.cs
@@ -8,20 +8,48 @@ using umbraco.cms.businesslogic.web;
 
 namespace Umbraco.Web.Routing
 {
+	/// <summary>
+	/// Provides utilities to handle domains.
+	/// </summary>
 	public class Domains
 	{
+		/// <summary>
+		/// Represents an Umbraco domain and its normalized uri.
+		/// </summary>
+		/// <remarks>
+		/// <para>In Umbraco it is valid to create domains with name such as <c>example.com</c>, <c>https://www.example.com</c>, <c>example.com/foo/</c>.</para>
+		/// <para>The normalized uri of a domain begins with a scheme and ends with no slash, eg <c>http://example.com/</c>, <c>https://www.example.com/</c>, <c>http://example.com/foo/</c>.</para>
+		/// </remarks>
 		public class DomainAndUri
 		{
+			/// <summary>
+			/// The Umbraco domain.
+			/// </summary>
 			public Domain Domain;
+
+			/// <summary>
+			/// The normalized uri of the domain.
+			/// </summary>
 			public Uri Uri;
 
+			/// <summary>
+			/// Gets a string that represents the <see cref="DomainAndUri"/> instance.
+			/// </summary>
+			/// <returns>A string that represents the current <see cref="DomainAndUri"/> instance.</returns>
 			public override string ToString()
 			{
 				return string.Format("{{ \"{0}\", \"{1}\" }}", Domain.Name, Uri);
 			}
 		}
 
-		public static DomainAndUri ApplicableDomains(IEnumerable<Domain> domains, Uri current, bool defaultToFirst)
+		/// <summary>
+		/// Finds the domain that best matches the current uri, into an enumeration of domains.
+		/// </summary>
+		/// <param name="domains">The enumeration of Umbraco domains.</param>
+		/// <param name="current">The uri of the current request, or null.</param>
+		/// <param name="defaultToFirst">A value indicating whether to return the first domain of the list when no domain matches.</param>
+		/// <returns>The domain and its normalized uri, that best matches the current uri, else the first domain (if <c>defaultToFirst</c> is <c>true</c>), else null.</returns>
+		public static DomainAndUri DomainMatch(IEnumerable<Domain> domains, Uri current, bool defaultToFirst)
 		{
 			if (!domains.Any())
 				return null;
@@ -57,6 +85,29 @@ namespace Umbraco.Web.Routing
 			return domainAndUri;
 		}
 
+		/// <summary>
+		/// Gets an enumeration of <see cref="DomainAndUri"/> matching an enumeration of Umbraco domains.
+		/// </summary>
+		/// <param name="domains">The enumeration of Umbraco domains.</param>
+		/// <param name="current">The uri of the current request, or null.</param>
+		/// <returns>The enumeration of <see cref="DomainAndUri"/> matching the enumeration of Umbraco domains.</returns>
+		public static IEnumerable<DomainAndUri> DomainMatches(IEnumerable<Domain> domains, Uri current)
+		{
+			var scheme = current == null ? Uri.UriSchemeHttp : current.Scheme;
+			var domainsAndUris = domains
+				.Select(d => new { Domain = d, UriString = UriUtility.TrimPathEndSlash(UriUtility.StartWithScheme(d.Name, scheme)) })
+				.OrderByDescending(t => t.UriString)
+				.Select(t => new DomainAndUri { Domain = t.Domain, Uri = new Uri(t.UriString) });
+			return domainsAndUris;
+		}
+
+		/// <summary>
+		/// Returns the part of a path relative to the uri of a domain.
+		/// </summary>
+		/// <param name="domainUri">The normalized uri of the domain.</param>
+		/// <param name="path">The full path of the uri.</param>
+		/// <returns>The path part relative to the uri of the domain.</returns>
+		/// <remarks>Eg the relative part of <c>/foo/bar/nil</c> to domain <c>example.com/foo</c> is <c>/bar/nil</c>.</remarks>
 		public static string PathRelativeToDomain(Uri domainUri, string path)
 		{
 			return path.Substring(domainUri.AbsolutePath.Length).EnsureStartsWith('/');
diff --git a/src/Umbraco.Web/Routing/IRoutesCache.cs b/src/Umbraco.Web/Routing/IRoutesCache.cs
index 0771fa556f..9033bc746e 100644
--- a/src/Umbraco.Web/Routing/IRoutesCache.cs
+++ b/src/Umbraco.Web/Routing/IRoutesCache.cs
@@ -1,19 +1,44 @@
 namespace Umbraco.Web.Routing
 {
-	// this is a bi-directional cache that contains
-	// - nodeId to route (used for NiceUrl)
-	// - route to nodeId (used for inbound requests)
-	//
-	// a route is [rootId]/path/to/node
-	// where rootId is the id of the "site root" node
-	//
-
+	/// <summary>
+	/// Represents a bi-directional cache that binds node identifiers and routes.
+	/// </summary>
+	/// <remarks>
+	/// <para>The cache is used both for inbound (map a route to a node) and outbound (map a node to a url).</para>
+	/// <para>A route is <c>[rootId]/path/to/node</c> where <c>rootId</c> is the id of the node holding an Umbraco domain, or -1.</para>
+	/// </remarks>
 	internal interface IRoutesCache
 	{
+		/// <summary>
+		/// Stores a route for a node.
+		/// </summary>
+		/// <param name="nodeId">The node identified.</param>
+		/// <param name="route">The route.</param>
 		void Store(int nodeId, string route);
+
+		/// <summary>
+		/// Gets a route for a node.
+		/// </summary>
+		/// <param name="nodeId">The node identifier.</param>
+		/// <returns>The route for the node, else null.</returns>
 		string GetRoute(int nodeId);
+
+		/// <summary>
+		/// Gets a node for a route.
+		/// </summary>
+		/// <param name="route">The route.</param>
+		/// <returns>The node identified for the route, else zero.</returns>
 		int GetNodeId(string route);
+
+		/// <summary>
+		/// Clears the route for a node.
+		/// </summary>
+		/// <param name="nodeId">The node identifier.</param>
 		void ClearNode(int nodeId);
+
+		/// <summary>
+		/// Clears all routes.
+		/// </summary>
 		void Clear();
 	}
 }
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/NiceUrlProvider.cs b/src/Umbraco.Web/Routing/NiceUrlProvider.cs
index 00a72b264c..a124ba1d13 100644
--- a/src/Umbraco.Web/Routing/NiceUrlProvider.cs
+++ b/src/Umbraco.Web/Routing/NiceUrlProvider.cs
@@ -13,10 +13,15 @@ using umbraco.cms.businesslogic.web;
 namespace Umbraco.Web.Routing
 {
 	/// <summary>
-	/// Resolves NiceUrls for a given node id
+	/// Provides nice urls for a nodes.
 	/// </summary>
     internal class NiceUrlProvider
     {
+		/// <summary>
+		/// Initializes a new instance of the <see cref="NiceUrlProvider"/> class.
+		/// </summary>
+		/// <param name="contentStore">The content store.</param>
+		/// <param name="umbracoContext">The Umbraco context.</param>
 		public NiceUrlProvider(ContentStore contentStore, UmbracoContext umbracoContext)
         {
             _umbracoContext = umbracoContext;
@@ -104,20 +109,67 @@ namespace Umbraco.Web.Routing
 		/// Gets the nice urls of a node.
 		/// </summary>
 		/// <param name="nodeId">The node id.</param>
+		/// <param name="current">The current url.</param>
 		/// <returns>An enumeration of all valid urls for the node.</returns>
 		/// <remarks>The urls are absolute. A node can have more than one url if more than one domain is defined.</remarks>
-		public IEnumerable<string> GetNiceUrls(int nodeId)
+		public IEnumerable<string> GetNiceUrls(int nodeId, Uri current)
 		{
-			// fixme - to be implemented
-			// this is for editContent.aspx which currently has its own, highly buggy, implementation of NiceUrl...
-			throw new NotImplementedException();
+			// this is for editContent.aspx which had its own, highly buggy, implementation of NiceUrl...
+			//TODO: finalize & test implementation then replace in editContent.aspx
+
+			string path;
+			IEnumerable<Uri> domainUris;
+
+			// will not read cache if previewing!
+			var route = _umbracoContext.InPreviewMode
+				? null
+				: _umbracoContext.RoutesCache.GetRoute(nodeId);
+
+			if (route != null)
+			{
+				// route is <id>/<path> eg "-1/", "-1/foo", "123/", "123/foo/bar"...
+				int pos = route.IndexOf('/');
+				path = route.Substring(pos);
+				int id = int.Parse(route.Substring(0, pos)); // will be -1 or 1234
+				domainUris = id > 0 ? DomainUrisAtNode(id, current) : new Uri[] { };
+			}
+			else
+			{
+				var node = _contentStore.GetNodeById(nodeId);
+				if (node == null)
+					return new string[] { "#" }; // legacy wrote to the log here...
+
+				var pathParts = new List<string>();
+				int id = nodeId;
+				domainUris = DomainUrisAtNode(id, current);
+				while (!domainUris.Any() && id > 0)
+				{
+					pathParts.Add(_contentStore.GetNodeProperty(node, UrlNameProperty));
+					node = _contentStore.GetNodeParent(node);
+					id = int.Parse(_contentStore.GetNodeProperty(node, "@id")); // will be -1 or 1234
+					domainUris = id > 0 ? DomainUrisAtNode(id, current) : new Uri[] { };
+				}
+
+				// no domain, respect HideTopLevelNodeFromPath for legacy purposes
+				if (!domainUris.Any() && global::umbraco.GlobalSettings.HideTopLevelNodeFromPath)
+					pathParts.RemoveAt(pathParts.Count - 1);
+
+				pathParts.Reverse();
+				path = "/" + string.Join("/", pathParts); // will be "/" or "/foo" or "/foo/bar" etc
+				route = id.ToString() + path;
+
+				if (!_umbracoContext.InPreviewMode)
+					_umbracoContext.RoutesCache.Store(nodeId, route);
+			}
+
+			return AssembleUrls(domainUris, path, current).Select(uri => uri.ToString());
 		}
 
-		Uri AssembleUrl(Uri domain, string path, Uri current, bool absolute)
+		Uri AssembleUrl(Uri domainUri, string path, Uri current, bool absolute)
 		{
 			Uri uri;
 
-			if (domain == null)
+			if (domainUri == null)
 			{
 				// no domain was found : return a relative url,  add vdir if any
 				uri = new Uri(global::umbraco.IO.SystemDirectories.Root + path, UriKind.Relative);
@@ -126,15 +178,28 @@ namespace Umbraco.Web.Routing
 			{
 				// a domain was found : return an absolute or relative url
 				// cannot handle vdir, has to be in domain uri
-				if (!absolute && current != null && domain.GetLeftPart(UriPartial.Authority) == current.GetLeftPart(UriPartial.Authority))
-					uri = new Uri(domain.AbsolutePath.TrimEnd('/') + path, UriKind.Relative); // relative
+				if (!absolute && current != null && domainUri.GetLeftPart(UriPartial.Authority) == current.GetLeftPart(UriPartial.Authority))
+					uri = new Uri(domainUri.AbsolutePath.TrimEnd('/') + path, UriKind.Relative); // relative
 				else
-					uri = new Uri(domain.GetLeftPart(UriPartial.Path).TrimEnd('/') + path); // absolute
+					uri = new Uri(domainUri.GetLeftPart(UriPartial.Path).TrimEnd('/') + path); // absolute
 			}
 
 			return UriFromUmbraco(uri);
 		}
 
+		IEnumerable<Uri> AssembleUrls(IEnumerable<Uri> domainUris, string path, Uri current)
+		{
+			if (domainUris.Any())
+			{
+				return domainUris.Select(domainUri => new Uri(domainUri.GetLeftPart(UriPartial.Path).TrimEnd('/') + path));
+			}
+			else
+			{
+				// no domain was found : return a relative url,  add vdir if any
+				return new Uri[] { new Uri(global::umbraco.IO.SystemDirectories.Root + path, UriKind.Relative) };
+			}
+		}
+
 		Uri DomainUriAtNode(int nodeId, Uri current)
 		{
 			// be safe
@@ -142,10 +207,20 @@ namespace Umbraco.Web.Routing
 				return null;
 
 			// apply filter on domains defined on that node
-			var domainAndUri = Domains.ApplicableDomains(Domain.GetDomainsById(nodeId), current, true);
+			var domainAndUri = Domains.DomainMatch(Domain.GetDomainsById(nodeId), current, true);
 			return domainAndUri == null ? null : domainAndUri.Uri;
 		}
 
+		IEnumerable<Uri> DomainUrisAtNode(int nodeId, Uri current)
+		{
+			// be safe
+			if (nodeId <= 0)
+				return new Uri[] { };
+
+			var domainAndUris = Domains.DomainMatches(Domain.GetDomainsById(nodeId), current);
+			return domainAndUris.Select(d => d.Uri);
+		}
+
 		#endregion
 
 		#region Map public urls to/from umbraco urls
diff --git a/src/Umbraco.Web/Routing/RoutesCacheResolver.cs b/src/Umbraco.Web/Routing/RoutesCacheResolver.cs
index 98d1114866..04a49f4e66 100644
--- a/src/Umbraco.Web/Routing/RoutesCacheResolver.cs
+++ b/src/Umbraco.Web/Routing/RoutesCacheResolver.cs
@@ -3,12 +3,22 @@ using Umbraco.Core.Resolving;
 
 namespace Umbraco.Web.Routing
 {
+	/// <summary>
+	/// Resolves the <see cref="IRoutesCache"/> implementation.
+	/// </summary>
 	class RoutesCacheResolver : SingleResolverBase<RoutesCacheResolver, IRoutesCache>
 	{
+		/// <summary>
+		/// Initializes a new instance of the <see cref="RoutesCacheResolve"/> class with an <see cref="IRoutesCache"/> implementation.
+		/// </summary>
+		/// <param name="routesCache">The <see cref="IRoutesCache"/> implementation.</param>
 		internal RoutesCacheResolver(IRoutesCache routesCache)
 			: base(routesCache)
 		{ }
 
+		/// <summary>
+		/// Gets or sets the <see cref="IRoutesCache"/> implementation.
+		/// </summary>
 		public IRoutesCache RoutesCache
 		{
 			get { return this.Value; }
diff --git a/src/Umbraco.Web/Routing/RoutingContext.cs b/src/Umbraco.Web/Routing/RoutingContext.cs
index 19aa35fea8..dbb3123034 100644
--- a/src/Umbraco.Web/Routing/RoutingContext.cs
+++ b/src/Umbraco.Web/Routing/RoutingContext.cs
@@ -5,11 +5,17 @@ namespace Umbraco.Web.Routing
 {
     
 	/// <summary>
-	/// represents a request for one specified Umbraco document to be rendered by one specified template, 
-	/// using one particular culture.
+	/// Provides context for the routing of a request.
 	/// </summary>
     internal class RoutingContext
     {
+		/// <summary>
+		/// Initializes a new instance of the <see cref="RoutingContext"/> class.
+		/// </summary>
+		/// <param name="umbracoContext">The Umbraco context.</param>
+		/// <param name="documentLookupsResolver">The document lookups resolver.</param>
+		/// <param name="contentStore">The content store.</param>
+		/// <param name="niceUrlResolver">The nice urls resolver.</param>
         public RoutingContext(
 			UmbracoContext umbracoContext,
 			DocumentLookupsResolver documentLookupsResolver,
@@ -22,9 +28,24 @@ namespace Umbraco.Web.Routing
         	this.NiceUrlProvider = niceUrlResolver;
         }
 
+		/// <summary>
+		/// Gets the Umbraco context.
+		/// </summary>
 		public UmbracoContext UmbracoContext { get; private set; }
+
+		/// <summary>
+		/// Gets the document lookups resolver.
+		/// </summary>
 		public DocumentLookupsResolver DocumentLookupsResolver { get; private set; }
+
+		/// <summary>
+		/// Gets the content store.
+		/// </summary>
         public ContentStore ContentStore { get; private set; }
+
+		/// <summary>
+		/// Gets the nice urls provider.
+		/// </summary>
 		public NiceUrlProvider NiceUrlProvider { get; private set; }
     }
 }
\ No newline at end of file