Fix tabs.

StephenClearyApps · May 16, 2018 · 796f146 · 796f146
1 parent a05b0aa
commit 796f146
Show file tree

Hide file tree

Showing 53 changed files with 1,328 additions and 1,328 deletions.
diff --git a/service/DotNetApis.Cecil/CecilExtensions.IsExposed.cs b/service/DotNetApis.Cecil/CecilExtensions.IsExposed.cs
@@ -53,7 +53,7 @@ public static bool IsExposed(this MethodDefinition method)
         /// Whether this property is accessible from another assembly (assuming its declaring type is accessible).
         /// </summary>
         public static bool IsExposed(this PropertyDefinition property) =>
-			(property.GetMethod != null && property.GetMethod.IsExposed()) || (property.SetMethod != null && property.SetMethod.IsExposed());
+            (property.GetMethod != null && property.GetMethod.IsExposed()) || (property.SetMethod != null && property.SetMethod.IsExposed());
 
         /// <summary>
         /// Whether this event is accessible from another assembly (assuming its declaring type is accessible).

diff --git a/service/DotNetApis.Cecil/CecilExtenstions.FriendlyName.cs b/service/DotNetApis.Cecil/CecilExtenstions.FriendlyName.cs
@@ -24,36 +24,36 @@ public static FriendlyName MemberFriendlyName(this IMemberDefinition member)
 
             if (member is MethodDefinition method)
             {
-	            var simpleName = GetSimpleName(method.SimpleMethodName(), method.GenericParameters);
-				return CreateFromDeclaringType(simpleName, declaringType, ns);
+                var simpleName = GetSimpleName(method.SimpleMethodName(), method.GenericParameters);
+                return CreateFromDeclaringType(simpleName, declaringType, ns);
             }
 
             return CreateFromDeclaringType(member.Name, declaringType, ns);
         }
 
-		/// <summary>
-		/// Gets a method name, using C# conventions instead of <c>.ctor</c>, <c>..ctor</c>, or <c>Finalize</c>. The returned name does not have a backtick suffix, nor does it have any generic parameters.
-		/// </summary>
-	    public static string SimpleMethodName(this MethodDefinition method)
-	    {
-		    var methodName = method.Name.StripBacktickSuffix().Name;
-		    if (methodName == ".ctor" || methodName == ".cctor")
-			    methodName = method.DeclaringType.Name.StripBacktickSuffix().Name;
-		    else if (methodName == "Finalize")
-			    methodName = "~" + method.DeclaringType.Name.StripBacktickSuffix().Name;
-		    return methodName;
-	    }
+        /// <summary>
+        /// Gets a method name, using C# conventions instead of <c>.ctor</c>, <c>..ctor</c>, or <c>Finalize</c>. The returned name does not have a backtick suffix, nor does it have any generic parameters.
+        /// </summary>
+        public static string SimpleMethodName(this MethodDefinition method)
+        {
+            var methodName = method.Name.StripBacktickSuffix().Name;
+            if (methodName == ".ctor" || methodName == ".cctor")
+                methodName = method.DeclaringType.Name.StripBacktickSuffix().Name;
+            else if (methodName == "Finalize")
+                methodName = "~" + method.DeclaringType.Name.StripBacktickSuffix().Name;
+            return methodName;
+        }
 
-		/// <summary>
-		/// Get a friendly name for the method overload group.
-		/// </summary>
-		public static FriendlyName OverloadFriendlyName(this MethodDefinition method)
+        /// <summary>
+        /// Get a friendly name for the method overload group.
+        /// </summary>
+        public static FriendlyName OverloadFriendlyName(this MethodDefinition method)
         {
             var ns = method.DeclaringTypesInnerToOuter().Last().Namespace;
-	        var simpleName = method.SimpleMethodName();
+            var simpleName = method.SimpleMethodName();
             var declaringType = string.Join(".", method.DeclaringType.GenericDeclaringTypesAndThis().Select(GetSimpleName));
             return CreateFromDeclaringType(simpleName, declaringType, ns); // Note: no generic parameters for overloads
-		}
+        }
 
         private static FriendlyName CreateFromDeclaringType(string simpleName, string declaringType, string ns) =>
             new FriendlyName(simpleName, declaringType + "." + simpleName, ns.DotAppend(declaringType + "." + simpleName));

diff --git a/service/DotNetApis.Common/AmbientContext.cs b/service/DotNetApis.Common/AmbientContext.cs
@@ -16,9 +16,9 @@ public static class AmbientContext
         private static readonly AsyncLocal<Guid> ImplicitParentOperationId = new AsyncLocal<Guid>();
         private static readonly AsyncLocal<string> ImplicitRequestId = new AsyncLocal<string>();
         private static readonly AsyncLocal<InMemoryLoggerProvider> ImplicitInMemoryLoggerProvider = new AsyncLocal<InMemoryLoggerProvider>();
-	    private static readonly AsyncLocal<JsonLoggerProvider> ImplicitJsonLoggerProvider = new AsyncLocal<JsonLoggerProvider>();
+        private static readonly AsyncLocal<JsonLoggerProvider> ImplicitJsonLoggerProvider = new AsyncLocal<JsonLoggerProvider>();
 
-		public static Guid OperationId
+        public static Guid OperationId
         {
             get => ImplicitOperationId.Value;
             set => ImplicitOperationId.Value = value;
@@ -47,14 +47,14 @@ public static InMemoryLoggerProvider InMemoryLoggerProvider
             set => ImplicitInMemoryLoggerProvider.Value = value;
         }
 
-	    /// <summary>
-	    /// May return <c>null</c>.
-	    /// </summary>
-	    public static JsonLoggerProvider JsonLoggerProvider
-	    {
-		    get => ImplicitJsonLoggerProvider.Value;
-		    set => ImplicitJsonLoggerProvider.Value = value;
-	    }
+        /// <summary>
+        /// May return <c>null</c>.
+        /// </summary>
+        public static JsonLoggerProvider JsonLoggerProvider
+        {
+            get => ImplicitJsonLoggerProvider.Value;
+            set => ImplicitJsonLoggerProvider.Value = value;
+        }
 
         /// <summary>
         /// Sets the values for HTTP-triggered API functions.

diff --git a/service/DotNetApis.Common/AsyncLocalAblyLoggerProvider.cs b/service/DotNetApis.Common/AsyncLocalAblyLoggerProvider.cs
@@ -7,58 +7,58 @@
 
 namespace DotNetApis.Common
 {
-	/// <summary>
-	/// A logger that attempts to write to an implicit Ably channel. This type can be safely created before its channel is created.
-	/// </summary>
-	public sealed class AsyncLocalAblyLoggerProvider : ILoggerProvider
-	{
-		private static readonly AsyncLocal<AblyChannel> ImplicitChannel = new AsyncLocal<AblyChannel>();
+    /// <summary>
+    /// A logger that attempts to write to an implicit Ably channel. This type can be safely created before its channel is created.
+    /// </summary>
+    public sealed class AsyncLocalAblyLoggerProvider : ILoggerProvider
+    {
+        private static readonly AsyncLocal<AblyChannel> ImplicitChannel = new AsyncLocal<AblyChannel>();
 
-		public static void TryCreate(string channelName, ILoggerFactory loggerFactory)
-		{
-			try
-			{
-				ImplicitChannel.Value = AblyService.CreateLogChannel(channelName);
-			}
-			catch (Exception ex)
-			{
-				loggerFactory.CreateLogger<Logging.AblyLogger>().AblyInitializationFailed(ex);
-			}
-		}
+        public static void TryCreate(string channelName, ILoggerFactory loggerFactory)
+        {
+            try
+            {
+                ImplicitChannel.Value = AblyService.CreateLogChannel(channelName);
+            }
+            catch (Exception ex)
+            {
+                loggerFactory.CreateLogger<Logging.AblyLogger>().AblyInitializationFailed(ex);
+            }
+        }
 
-		void IDisposable.Dispose() { }
+        void IDisposable.Dispose() { }
 
-		public ILogger CreateLogger(string categoryName) => new AsyncLocalAblyLogger();
+        public ILogger CreateLogger(string categoryName) => new AsyncLocalAblyLogger();
 
-		private sealed class AsyncLocalAblyLogger : ILogger
-		{
-			public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
-			{
-				if (IsEnabled(logLevel))
-				{
-					var message = formatter(state, exception) ?? "";
-					if (exception != null)
-					{
-						if (message != "")
-							message += ": ";
-						message += $"[{exception.GetType().Name}]: {exception.Message}";
-					}
+        private sealed class AsyncLocalAblyLogger : ILogger
+        {
+            public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+            {
+                if (IsEnabled(logLevel))
+                {
+                    var message = formatter(state, exception) ?? "";
+                    if (exception != null)
+                    {
+                        if (message != "")
+                            message += ": ";
+                        message += $"[{exception.GetType().Name}]: {exception.Message}";
+                    }
 
-					ImplicitChannel.Value?.LogMessage(logLevel.ToString(), message);
-				}
-			}
+                    ImplicitChannel.Value?.LogMessage(logLevel.ToString(), message);
+                }
+            }
 
-			public bool IsEnabled(LogLevel logLevel) => ImplicitChannel.Value != null && logLevel >= LogLevel.Information && logLevel != LogLevel.Warning;
+            public bool IsEnabled(LogLevel logLevel) => ImplicitChannel.Value != null && logLevel >= LogLevel.Information && logLevel != LogLevel.Warning;
 
-			public IDisposable BeginScope<TState>(TState state) => throw new NotImplementedException();
-		}
-	}
+            public IDisposable BeginScope<TState>(TState state) => throw new NotImplementedException();
+        }
+    }
 
-	internal static partial class Logging
-	{
-		public static void AblyInitializationFailed(this ILogger<AblyLogger> logger, Exception ex) =>
-			Logger.Log(logger, 1, LogLevel.Warning, "Could not initialize Ably", ex);
+    internal static partial class Logging
+    {
+        public static void AblyInitializationFailed(this ILogger<AblyLogger> logger, Exception ex) =>
+            Logger.Log(logger, 1, LogLevel.Warning, "Could not initialize Ably", ex);
 
-		public sealed class AblyLogger { }
-	}
+        public sealed class AblyLogger { }
+    }
 }
diff --git a/service/DotNetApis.Common/AsyncLocalLoggerFactory.cs b/service/DotNetApis.Common/AsyncLocalLoggerFactory.cs
@@ -15,18 +15,18 @@ public sealed class AsyncLocalLoggerFactory : ILoggerFactory
 
         public AsyncLocalLoggerFactory()
         {
-			_loggerFactory = LoggerFactory;
+            _loggerFactory = LoggerFactory;
         }
 
         public static ILoggerFactory LoggerFactory
-		{
+        {
             get => ImplicitLoggerFactory.Value;
             set => ImplicitLoggerFactory.Value = value;
         }
 
-		// SimpleInjectory's Verify creates and then disposes its instances, so we do not dispose our (AsyncLocal) instance.
-	    void IDisposable.Dispose() { }
-	    ILogger ILoggerFactory.CreateLogger(string categoryName) => _loggerFactory?.CreateLogger(categoryName);
-	    void ILoggerFactory.AddProvider(ILoggerProvider provider) => _loggerFactory?.AddProvider(provider);
+        // SimpleInjectory's Verify creates and then disposes its instances, so we do not dispose our (AsyncLocal) instance.
+        void IDisposable.Dispose() { }
+        ILogger ILoggerFactory.CreateLogger(string categoryName) => _loggerFactory?.CreateLogger(categoryName);
+        void ILoggerFactory.AddProvider(ILoggerProvider provider) => _loggerFactory?.AddProvider(provider);
     }
 }
diff --git a/service/DotNetApis.Common/Compression.cs b/service/DotNetApis.Common/Compression.cs
@@ -16,7 +16,7 @@ public static class Compression
         /// <param name="logger">The logger to log compression statistics to. May be <c>null</c>.</param>
         public static (byte[], int) GzipString(string data, ILoggerFactory loggerFactory)
         {
-	        var logger = loggerFactory?.CreateLogger<Logging.Compression>();
+            var logger = loggerFactory?.CreateLogger<Logging.Compression>();
 
             var dataBytes = Constants.Utf8.GetBytes(data);
             using (var stream = new MemoryStream())
@@ -30,12 +30,12 @@ public static (byte[], int) GzipString(string data, ILoggerFactory loggerFactory
         }
     }
 
-	internal static partial class Logging
-	{
-		public static void Stats(this ILogger<Compression> logger, int uncompressedCharacters, int uncompressedBytes, int compressedBytes) =>
-			Logger.Log(logger, 1, LogLevel.Debug, "Before compression, string was {uncompressedBytes} bytes ({uncompressedCharacters} chars); after compression, string is {compressedBytes} bytes",
-				uncompressedBytes, uncompressedCharacters, compressedBytes, null);
+    internal static partial class Logging
+    {
+        public static void Stats(this ILogger<Compression> logger, int uncompressedCharacters, int uncompressedBytes, int compressedBytes) =>
+            Logger.Log(logger, 1, LogLevel.Debug, "Before compression, string was {uncompressedBytes} bytes ({uncompressedCharacters} chars); after compression, string is {compressedBytes} bytes",
+                uncompressedBytes, uncompressedCharacters, compressedBytes, null);
 
-		public sealed class Compression { }
-	}
+        public sealed class Compression { }
+    }
 }
diff --git a/service/DotNetApis.Common/ForwardingLoggerProvider.cs b/service/DotNetApis.Common/ForwardingLoggerProvider.cs
@@ -7,20 +7,20 @@
 
 namespace DotNetApis.Common
 {
-	/// <summary>
-	/// A logger provider whose loggers all forward to a single underlying <see cref="ILogger"/>.
-	/// </summary>
+    /// <summary>
+    /// A logger provider whose loggers all forward to a single underlying <see cref="ILogger"/>.
+    /// </summary>
     public sealed class ForwardingLoggerProvider: ILoggerProvider
     {
-	    private readonly ILogger _logger;
+        private readonly ILogger _logger;
 
-	    public ForwardingLoggerProvider(ILogger logger)
-	    {
-		    _logger = logger;
-	    }
+        public ForwardingLoggerProvider(ILogger logger)
+        {
+            _logger = logger;
+        }
 
-	    void IDisposable.Dispose() { }
+        void IDisposable.Dispose() { }
 
-	    public ILogger CreateLogger(string categoryName) => _logger;
+        public ILogger CreateLogger(string categoryName) => _logger;
     }
 }
diff --git a/service/DotNetApis.Common/InMemoryLoggerProvider.cs b/service/DotNetApis.Common/InMemoryLoggerProvider.cs
@@ -6,54 +6,54 @@
 
 namespace DotNetApis.Common
 {
-	/// <summary>
-	/// A logger that writes messages to a an in-memory list.
-	/// </summary>
-	public sealed class InMemoryLoggerProvider : ILoggerProvider
-	{
-		private readonly List<LogMessage> _messages = new List<LogMessage>();
-
-		public List<LogMessage> Messages
-		{
-			get { lock (_messages) return _messages.ToList(); }
-		}
-
-		void IDisposable.Dispose() { }
-
-		public ILogger CreateLogger(string categoryName) => new InMemoryLogger(this, categoryName);
-
-		private void Log<TState>(string categoryName, LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
-		{
-			var message = new LogMessage
-			{
-				Type = logLevel,
-				Timestamp = DateTimeOffset.UtcNow,
-				Message = formatter(state, exception) + (exception == null ? "" : "\r\n" + exception),
-				Category = categoryName,
-				EventId = eventId.Id,
-			};
-
-			lock (_messages)
-				_messages.Add(message);
-		}
-
-		private sealed class InMemoryLogger : ILogger
-		{
-			private readonly InMemoryLoggerProvider _provider;
-			private readonly string _categoryName;
-
-			public InMemoryLogger(InMemoryLoggerProvider provider, string categoryName)
-			{
-				_provider = provider;
-				_categoryName = categoryName;
-			}
-
-			public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
-				=> _provider.Log(_categoryName, logLevel, eventId, state, exception, formatter);
-
-			public bool IsEnabled(LogLevel logLevel) => true;
-
-			public IDisposable BeginScope<TState>(TState state) => throw new NotImplementedException();
-		}
-	}
+    /// <summary>
+    /// A logger that writes messages to a an in-memory list.
+    /// </summary>
+    public sealed class InMemoryLoggerProvider : ILoggerProvider
+    {
+        private readonly List<LogMessage> _messages = new List<LogMessage>();
+
+        public List<LogMessage> Messages
+        {
+            get { lock (_messages) return _messages.ToList(); }
+        }
+
+        void IDisposable.Dispose() { }
+
+        public ILogger CreateLogger(string categoryName) => new InMemoryLogger(this, categoryName);
+
+        private void Log<TState>(string categoryName, LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+        {
+            var message = new LogMessage
+            {
+                Type = logLevel,
+                Timestamp = DateTimeOffset.UtcNow,
+                Message = formatter(state, exception) + (exception == null ? "" : "\r\n" + exception),
+                Category = categoryName,
+                EventId = eventId.Id,
+            };
+
+            lock (_messages)
+                _messages.Add(message);
+        }
+
+        private sealed class InMemoryLogger : ILogger
+        {
+            private readonly InMemoryLoggerProvider _provider;
+            private readonly string _categoryName;
+
+            public InMemoryLogger(InMemoryLoggerProvider provider, string categoryName)
+            {
+                _provider = provider;
+                _categoryName = categoryName;
+            }
+
+            public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+                => _provider.Log(_categoryName, logLevel, eventId, state, exception, formatter);
+
+            public bool IsEnabled(LogLevel logLevel) => true;
+
+            public IDisposable BeginScope<TState>(TState state) => throw new NotImplementedException();
+        }
+    }
 }