Reformat

Added ability to sort by dependency or by config file order
Added .editorconfig file for indentation management

.editorconfig

@@ -0,0 +1,7 @@
+; Top-most EditorConfig file
+root = true
+
+; 4-column space indentation
+[*]
+indent_style = tab
+indent_size = 4

src/Unicorn/Configuration/ConfigurationDependency.cs

@@ -2,21 +2,21 @@
 
 namespace Unicorn.Configuration
 {
-    class ItemConfigurationDependency : IConfigurationDependency
-    {
-        public IConfiguration Configuration { get; }
-        public TreeRoot Root { get; set; }
-        public string ItemPath { get; }
-        public string GetLogMessage()
-        {
-            return $"The <include> '{Root.Name}' needs '{ItemPath}' from the configuration '{Configuration.Name}'";
-        }
+	class ItemConfigurationDependency : IConfigurationDependency
+	{
+		public IConfiguration Configuration { get; }
+		public TreeRoot Root { get; set; }
+		public string ItemPath { get; }
+		public string GetLogMessage()
+		{
+			return $"The <include> '{Root.Name}' needs '{ItemPath}' from the configuration '{Configuration.Name}'";
+		}
 
-        public ItemConfigurationDependency(IConfiguration configuration, TreeRoot root, string itemPath)
-        {
-            Configuration = configuration;
-            Root = root;
-            ItemPath = itemPath;
-        }
-    }
+		public ItemConfigurationDependency(IConfiguration configuration, TreeRoot root, string itemPath)
+		{
+			Configuration = configuration;
+			Root = root;
+			ItemPath = itemPath;
+		}
+	}
 }

src/Unicorn/Configuration/ConfigurationDependencyResolver.cs

@@ -5,78 +5,78 @@
 
 namespace Unicorn.Configuration
 {
-    public class ConfigurationDependencyResolver
-    {
-        private static readonly IDictionary<IConfiguration, IConfigurationDependency[]> _dependencyCache = new Dictionary<IConfiguration, IConfigurationDependency[]>();
+	public class ConfigurationDependencyResolver
+	{
+		private static readonly IDictionary<IConfiguration, IConfigurationDependency[]> _dependencyCache = new Dictionary<IConfiguration, IConfigurationDependency[]>();
 
-        private IConfigurationDependency[] _dependencies;
-        private IConfiguration[] _dependants;
-        public IConfiguration Configuration { get; set; }
+		private IConfigurationDependency[] _dependencies;
+		private IConfiguration[] _dependents;
+		public IConfiguration Configuration { get; set; }
 
-        public ConfigurationDependencyResolver(IConfiguration configuration)
-        {
-            Configuration = configuration;
-        }
+		public ConfigurationDependencyResolver(IConfiguration configuration)
+		{
+			Configuration = configuration;
+		}
 
-        public IConfigurationDependency[] Dependencies => _dependencies ?? (_dependencies = ResolveDependencies());
-        public IConfiguration[] Dependants => _dependants ?? (_dependants = ResolveDependants());
+		public IConfigurationDependency[] Dependencies => _dependencies ?? (_dependencies = ResolveDependencies());
+		public IConfiguration[] Dependents => _dependents ?? (_dependents = ResolveDependents());
 
-        private IConfiguration[] ResolveDependants()
-        {
-            return UnicornConfigurationManager.Configurations.Where(c => c.Resolve<ConfigurationDependencyResolver>().Dependencies.Any(d => d.Configuration.Name.Equals(Configuration.Name, StringComparison.CurrentCultureIgnoreCase))).ToArray();
-        }
+		private IConfiguration[] ResolveDependents()
+		{
+			return UnicornConfigurationManager.Configurations.Where(c => c.Resolve<ConfigurationDependencyResolver>().Dependencies.Any(d => d.Configuration.Name.Equals(Configuration.Name, StringComparison.CurrentCultureIgnoreCase))).ToArray();
+		}
 
-        private IConfigurationDependency[] ResolveDependencies()
-        {
-            if (_dependencyCache.ContainsKey(Configuration))
-                return _dependencyCache[Configuration];
-            var explicitDependencies = GetExplicitDependencies();
-            var dependencies = GetRootDependencies().Union(explicitDependencies).ToArray();
-            _dependencyCache.Add(Configuration, dependencies);
-            return dependencies;
-        }
+		private IConfigurationDependency[] ResolveDependencies()
+		{
+			if (_dependencyCache.ContainsKey(Configuration))
+				return _dependencyCache[Configuration];
+			var explicitDependencies = GetExplicitDependencies();
+			var dependencies = GetRootDependencies().Union(explicitDependencies).ToArray();
+			_dependencyCache.Add(Configuration, dependencies);
+			return dependencies;
+		}
 
-        private IEnumerable<IConfigurationDependency> GetExplicitDependencies()
-        {
-            if (Configuration.Dependencies == null)
-                return new IConfigurationDependency[] {};
+		private IEnumerable<IConfigurationDependency> GetExplicitDependencies()
+		{
+			if (Configuration.Dependencies == null)
+				return new IConfigurationDependency[] {};
 
-            var dependencies = UnicornConfigurationManager.Configurations.Where(c => Configuration.Dependencies.Any(d => d.Equals(c.Name, StringComparison.InvariantCultureIgnoreCase)));
-            return dependencies.Select(c => (IConfigurationDependency)new ExplicitConfigurationDependency(c));
-        }
+			var dependencies = UnicornConfigurationManager.Configurations.Where(c => Configuration.Dependencies.Any(d => d.Equals(c.Name, StringComparison.InvariantCultureIgnoreCase)));
+			return dependencies.Select(c => (IConfigurationDependency)new ExplicitConfigurationDependency(c));
+		}
 
-        private IEnumerable<IConfigurationDependency> GetRootDependencies()
-        {
-            var otherConfigurations = UnicornConfigurationManager.Configurations.Where(c => c.Name != Configuration.Name).ToArray();
+		private IEnumerable<IConfigurationDependency> GetRootDependencies()
+		{
+			var otherConfigurations = UnicornConfigurationManager.Configurations.Where(c => c.Name != Configuration.Name).ToArray();
 
-            var currentPredicate = Configuration.Resolve<PredicateRootPathResolver>();
-            foreach (var rootPath in currentPredicate.GetRootPaths())
-            {
-                var parentPath = GetParentPath(rootPath.Path);
+			var currentPredicate = Configuration.Resolve<PredicateRootPathResolver>();
+			foreach (var rootPath in currentPredicate.GetRootPaths())
+			{
+				var parentPath = GetParentPath(rootPath.Path);
 
-                //If the parent is found in the source data store, then there is not dependency on this
-                var item = currentPredicate.SourceDataStore.GetByPath(parentPath, rootPath.DatabaseName).FirstOrDefault();
-                if (item != null)
-                    continue;
+				//If the parent is found in the source data store, then there is not dependency on this
+				var item = currentPredicate.SourceDataStore.GetByPath(parentPath, rootPath.DatabaseName).FirstOrDefault();
+				if (item != null)
+					continue;
 
-                //Look for parent in other configurations
-                foreach (var otherConfiguration in otherConfigurations)
-                {
-                    //If the parent is found in a target data store, then we have a dependency
-                    var dataStore = otherConfiguration.Resolve<PredicateRootPathResolver>().TargetDataStore;
-                    item = dataStore.GetByPath(parentPath, rootPath.DatabaseName).FirstOrDefault();
-                    if (item == null)
-                        continue;
-                    yield return new ItemConfigurationDependency(otherConfiguration, rootPath, parentPath);
-                    break;
-                }
-            }
-        }
+				//Look for parent in other configurations
+				foreach (var otherConfiguration in otherConfigurations)
+				{
+					//If the parent is found in a target data store, then we have a dependency
+					var dataStore = otherConfiguration.Resolve<PredicateRootPathResolver>().TargetDataStore;
+					item = dataStore.GetByPath(parentPath, rootPath.DatabaseName).FirstOrDefault();
+					if (item == null)
+						continue;
+					yield return new ItemConfigurationDependency(otherConfiguration, rootPath, parentPath);
+					break;
+				}
+			}
+		}
 
-        private static string GetParentPath(string rootPath)
-        {
-            var path = rootPath.TrimEnd('/');
-            return path.Substring(0, path.LastIndexOf('/'));
-        }
-    }
+		private static string GetParentPath(string rootPath)
+		{
+			var path = rootPath.TrimEnd('/');
+			return path.Substring(0, path.LastIndexOf('/'));
+		}
+	}
 }

src/Unicorn/Configuration/ExplicitConfigurationDependency.cs

@@ -1,16 +1,16 @@
 namespace Unicorn.Configuration
 {
-    internal class ExplicitConfigurationDependency : IConfigurationDependency
-    {
-        public ExplicitConfigurationDependency(IConfiguration configuration)
-        {
-            this.Configuration = configuration;
-        }
+	internal class ExplicitConfigurationDependency : IConfigurationDependency
+	{
+		public ExplicitConfigurationDependency(IConfiguration configuration)
+		{
+			this.Configuration = configuration;
+		}
 
-        public IConfiguration Configuration { get; }
-        public string GetLogMessage()
-        {
-            return $"There is an explicit dependency on '{Configuration.Name}' in the configuration.";
-        }
-    }
+		public IConfiguration Configuration { get; }
+		public string GetLogMessage()
+		{
+			return $"There is an explicit dependency on '{Configuration.Name}' in the configuration.";
+		}
+	}
 }

src/Unicorn/Configuration/IConfiguration.cs

@@ -18,15 +18,15 @@ public interface IConfiguration
 		/// </summary>
 		string Description { get; }
 
-        /// <summary>
-        /// A list of configurations on which this configuration depends
-        /// </summary>
-        string[] Dependencies { get; }
+		/// <summary>
+		/// A list of configurations on which this configuration depends
+		/// </summary>
+		string[] Dependencies { get; }
 
-        /// <summary>
-        /// Resolves an instance of a type from a generic parameter. This should be an explicitly registered type.
-        /// </summary>
-        T Resolve<T>() where T : class;
+		/// <summary>
+		/// Resolves an instance of a type from a generic parameter. This should be an explicitly registered type.
+		/// </summary>
+		T Resolve<T>() where T : class;
 
 		/// <summary>
 		/// Resolves an instance of a type from a Type instance

src/Unicorn/Configuration/IConfigurationDependency.cs

@@ -2,17 +2,17 @@
 
 namespace Unicorn.Configuration
 {
-    public interface IConfigurationDependency
-    {
-        /// <summary>
-        /// Which configuration is it dependent on.
-        /// </summary>
-        IConfiguration Configuration { get; }
+	public interface IConfigurationDependency
+	{
+		/// <summary>
+		/// Which configuration is it dependent on.
+		/// </summary>
+		IConfiguration Configuration { get; }
 
-        /// <summary>
-        /// Returns a human readable string describing the dependency 
-        /// </summary>
-        /// <returns></returns>
-        string GetLogMessage();
-    }
+		/// <summary>
+		/// Returns a human readable string describing the dependency 
+		/// </summary>
+		/// <returns></returns>
+		string GetLogMessage();
+	}
 }

src/Unicorn/Configuration/MicroConfiguration.cs

@@ -16,14 +16,14 @@ public MicroConfiguration(string name, string description, string[] dependencies
 		{
 			Name = name;
 			Description = description;
-		    Dependencies = dependencies;
+			Dependencies = dependencies ?? new string[] {};
 		}
 
 		public string Name { get; }
 		public string Description { get; }
-	    public string[] Dependencies { get; set; }
+		public string[] Dependencies { get; set; }
 
-	    /// <summary>
+		/// <summary>
 		/// Resolves a registered type with its dependencies. Note: to activate unregistered types and inject dependencies use Activate() instead.
 		/// </summary>
 		/// <typeparam name="T">Type to resolve</typeparam>

src/Unicorn/Configuration/ReadOnlyConfiguration.cs

@@ -20,9 +20,9 @@ public ReadOnlyConfiguration(IConfiguration innerConfiguration)
 
 		public string Name { get { return _innerConfiguration.Name; }}
 		public string Description { get { return _innerConfiguration.Description; } }
-	    public string[] Dependencies { get { return _innerConfiguration.Dependencies; } }
+		public string[] Dependencies { get { return _innerConfiguration.Dependencies; } }
 
-        public T Resolve<T>() where T : class
+		public T Resolve<T>() where T : class
 		{
 			return _innerConfiguration.Resolve<T>();
 		}

src/Unicorn/Configuration/UnicornConfigurationManager.cs

@@ -17,9 +17,9 @@ static UnicornConfigurationManager()
 
 		public static IConfiguration[] Configurations => Instance.Configurations;
 
-	    public static IConfiguration[] GetConfigurationsOrdererdByDependants()
-	    {
-	        return Configurations.OrderByDescending(configuration => configuration.Resolve<ConfigurationDependencyResolver>().Dependants.Length).ThenBy(configuration => configuration.Name).ToArray();
-        }
-    }
+		public static IConfiguration[] GetConfigurationsOrdererdByDependents()
+		{
+			return Configurations.OrderByDescending(configuration => configuration.Resolve<ConfigurationDependencyResolver>().Dependents.Length).ThenBy(configuration => configuration.Name).ToArray();
+		}
+	}
 }

src/Unicorn/Configuration/XmlConfigurationProvider.cs

@@ -21,20 +21,20 @@ namespace Unicorn.Configuration
 	/// </summary>
 	public class XmlConfigurationProvider : IConfigurationProvider
 	{
-        private IConfiguration[] _configurations;
+		private IConfiguration[] _configurations;
 
 		public IConfiguration[] Configurations
 		{
 			get
 			{
 				if (_configurations == null)
-                    LoadConfigurations();
+					LoadConfigurations();
 				return _configurations;
 			}
 		}
 
 
-        protected virtual XmlNode GetConfigurationNode()
+		protected virtual XmlNode GetConfigurationNode()
 		{
 			return Factory.GetConfigNode("/sitecore/unicorn");
 		}
@@ -81,10 +81,10 @@ protected virtual IConfiguration LoadConfiguration(XmlElement configuration, Xml
 
 			var description = GetAttributeValue(configuration, "description");
 
-		    var attributeValue = GetAttributeValue(configuration, "dependencies");
-		    var dependencies = !string.IsNullOrEmpty(attributeValue) ? attributeValue.Split("|;, ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries) : null;
+			var attributeValue = GetAttributeValue(configuration, "dependencies");
+			var dependencies = !string.IsNullOrEmpty(attributeValue) ? attributeValue.Split("|;, ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries) : null;
 
-            var registry = new MicroConfiguration(name, description, dependencies);
+			var registry = new MicroConfiguration(name, description, dependencies);
 
 			// these are config types we absolutely must have instances of to use Unicorn - an exception will throw if they don't exist
 			var configMapping = new Dictionary<string, Action<XmlElement, XmlElement, string, IConfiguration>>
@@ -96,8 +96,8 @@ protected virtual IConfiguration LoadConfiguration(XmlElement configuration, Xml
 				{"logger", RegisterExpectedConfigType<ILogger>},
 				{"loaderLogger", RegisterExpectedConfigType<ISerializationLoaderLogger>},
 				{"loaderConsistencyChecker", RegisterExpectedConfigType<IConsistencyChecker>},
-                {"loaderDeserializeFailureRetryer", RegisterExpectedConfigType<IDeserializeFailureRetryer>}
-            };
+				{"loaderDeserializeFailureRetryer", RegisterExpectedConfigType<IDeserializeFailureRetryer>}
+			};
 
 			foreach (var explicitMapping in configMapping)
 			{