Fixed tabs and spaces, internal class, and memory management for incoming requests

Author: Marcin Drobik

src/React.Owin/AssemblyRegistration.cs

@@ -23,8 +23,8 @@ public class AssemblyRegistration : IAssemblyRegistration
 		/// <param name="container">Container to register components in</param>
 		public void Register(TinyIoCContainer container)
 		{
-            container.Register<IFileSystem, EntryAssemblyFileSystem>();
-            container.Register<ICache, MemoryFileCache>();
+			container.Register<IFileSystem, EntryAssemblyFileSystem>();
+			container.Register<ICache, MemoryFileCache>();
 		}
 	}
 }

src/React.Owin/JsxFileMiddleware.cs

@@ -21,11 +21,14 @@ namespace React.Owin
 	/// </summary>
 	public class JsxFileMiddleware
 	{
-		private readonly StaticFileMiddleware _internalStaticMiddleware;
+		private readonly Func<IDictionary<string, object>, Task> _next;
+		private readonly StaticFileOptions _fileOptions;
+		private readonly IEnumerable<string> _extensions;
 
 		static JsxFileMiddleware()
 		{
-			Initializer.Initialize(_ => _);
+			// Assume that request will ask for the "per request" instances only once. 
+			Initializer.Initialize(options => options.AsMultiInstance());
 		}
 
 		/// <summary>
@@ -38,34 +41,46 @@ public JsxFileMiddleware(Func<IDictionary<string, object>, Task> next, JsxFileOp
 			if (next == null)
 				throw new ArgumentNullException("next");
 
+			_next = next;
+
 			// Default values
 			options = options ?? new JsxFileOptions();
-			var extensions = (options.Extensions == null || !options.Extensions.Any()) ? new[] { ".jsx", ".js" } : options.Extensions;
-			var fileOptions = options.StaticFileOptions ?? new StaticFileOptions();
-
-			// Wrap the file system with JSX file system
-			var reactEnvironment = React.AssemblyRegistration.Container.Resolve<IReactEnvironment>();
-			_internalStaticMiddleware = new StaticFileMiddleware(
-				next,
-				new StaticFileOptions()
-				{
-					ContentTypeProvider = fileOptions.ContentTypeProvider,
-					DefaultContentType = fileOptions.DefaultContentType,
-					OnPrepareResponse = fileOptions.OnPrepareResponse,
-					RequestPath = fileOptions.RequestPath,
-					ServeUnknownFileTypes = fileOptions.ServeUnknownFileTypes,
-					FileSystem = new JsxFileSystem(reactEnvironment.JsxTransformer, fileOptions.FileSystem, extensions)
-				});
+			_extensions = (options.Extensions == null || !options.Extensions.Any()) ? new[] { ".jsx", ".js" } : options.Extensions;
+			_fileOptions = options.StaticFileOptions ?? new StaticFileOptions();
 		}
 
 		/// <summary>
 		/// Processes a request to determine if it matches a known JSX file, and if so, serves it compiled to JavaScript.
 		/// </summary>
 		/// <param name="environment">OWIN environment dictionary which stores state information about the request, response and relevant server state.</param>
 		/// <returns/>
-		public Task Invoke(IDictionary<string, object> environment)
+		public async Task Invoke(IDictionary<string, object> environment)
 		{
-			return _internalStaticMiddleware.Invoke(environment);
+			// Create all "per request" instances
+			var reactEnvironment = React.AssemblyRegistration.Container.Resolve<IReactEnvironment>();
+
+			var internalStaticMiddleware = CreateFileMiddleware(reactEnvironment.JsxTransformer);
+			await internalStaticMiddleware.Invoke(environment);
+
+			// Clean up all "per request" instances
+			var disposable = reactEnvironment as IDisposable;
+			if (disposable != null)
+				disposable.Dispose();
+		}
+
+		private StaticFileMiddleware CreateFileMiddleware(IJsxTransformer jsxTransformer)
+		{
+			return new StaticFileMiddleware(
+				_next,
+				new StaticFileOptions()
+				{
+					ContentTypeProvider = _fileOptions.ContentTypeProvider,
+					DefaultContentType = _fileOptions.DefaultContentType,
+					OnPrepareResponse = _fileOptions.OnPrepareResponse,
+					RequestPath = _fileOptions.RequestPath,
+					ServeUnknownFileTypes = _fileOptions.ServeUnknownFileTypes,
+					FileSystem = new JsxFileSystem(jsxTransformer, _fileOptions.FileSystem, _extensions)
+				});
 		}
 	}
 }

src/React.Owin/JsxFileSystem.cs

@@ -20,17 +20,29 @@ namespace React.Owin
 	/// <summary>
 	/// Owin file system that serves transformed JSX files.
 	/// </summary>
-	internal class JsxFileSystem : Microsoft.Owin.FileSystems.IFileSystem
+	public class JsxFileSystem : Microsoft.Owin.FileSystems.IFileSystem
 	{
 		private readonly IJsxTransformer _transformer;
 		private readonly Microsoft.Owin.FileSystems.IFileSystem _physicalFileSystem;
 		private readonly string[] _extensions;
 
+		/// <summary>
+		/// Creates a new instance of the JsxFileSystem.
+		/// </summary>
+		/// <param name="transformer">JSX transformer used to compile JSX files</param>
+		/// <param name="root">The root directory</param>
+		/// <param name="extensions">Extensions of files that will be treated as JSX files</param>
 		public JsxFileSystem(IJsxTransformer transformer, string root, IEnumerable<string> extensions)
 			: this(transformer, new PhysicalFileSystem(root), extensions)
 		{            
 		}
 
+		/// <summary>
+		/// Creates a new instance of the JsxFileSystem.
+		/// </summary>
+		/// <param name="transformer">JSX transformer used to compile JSX files</param>
+		/// <param name="fileSystem">File system used to look up files</param>
+		/// <param name="extensions">Extensions of files that will be treated as JSX files</param>
 		public JsxFileSystem(IJsxTransformer transformer, Microsoft.Owin.FileSystems.IFileSystem fileSystem, IEnumerable<string> extensions)
 		{
 			_transformer = transformer;
@@ -40,6 +52,14 @@ public JsxFileSystem(IJsxTransformer transformer, Microsoft.Owin.FileSystems.IFi
 			_extensions = extensions.Select(extension => extension.StartsWith(".") ? extension : "." + extension).ToArray();
 		}
 
+		/// <summary>
+		/// Locate a JSX file at the given path. 
+		/// </summary>
+		/// <param name="subpath">The path that identifies the file</param>
+		/// <param name="fileInfo">The discovered file if any</param>
+		/// <returns>
+		/// True if a JSX file was located at the given path
+		/// </returns>
 		public bool TryGetFileInfo(string subpath, out IFileInfo fileInfo)
 		{
 			IFileInfo internalFileInfo;
@@ -55,6 +75,14 @@ public bool TryGetFileInfo(string subpath, out IFileInfo fileInfo)
 			return true;
 		}
 
+		/// <summary>
+		/// Enumerate a directory at the given path, if any
+		/// </summary>
+		/// <param name="subpath">The path that identifies the directory</param>
+		/// <param name="contents">The contents if any</param>
+		/// <returns>
+		/// True if a directory was located at the given path
+		/// </returns>
 		public bool TryGetDirectoryContents(string subpath, out IEnumerable<IFileInfo> contents)
 		{
 			return _physicalFileSystem.TryGetDirectoryContents(subpath, out contents);