Initial comit of React.Owin, sample included

Author: Marcin Drobik

src/React.Owin/EntryAssemblyFileSystem.cs

@@ -0,0 +1,28 @@
+/*
+ *  Copyright (c) 2014-2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant 
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using System.IO;
+using System.Reflection;
+
+namespace React.Owin
+{
+    /// <summary>
+    /// Implements React file system that maps "~" into entry assembly location.
+    /// </summary>
+    internal class EntryAssemblyFileSystem : FileSystemBase
+    {
+        public override string MapPath(string relativePath)
+        {
+            if (relativePath.StartsWith("~"))
+                return Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), relativePath.Replace("~", string.Empty));
+
+            return relativePath;
+        }
+    }
+}

src/React.Owin/JsxFileExtensions.cs

@@ -0,0 +1,35 @@
+/*
+ *  Copyright (c) 2014-2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant 
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using Owin;
+
+namespace React.Owin
+{
+    /// <summary>
+    /// Extensions for JsxFileMiddleware.
+    /// </summary>
+    public static class JsxFileExtensions
+    {
+        /// <summary>
+        /// Enables serving static JSX file, compiled to JavaScript, for the current request path from the current directory.
+        /// </summary> 
+        public static IAppBuilder UseJsxFiles(this IAppBuilder builder)
+        {
+            return builder.UseJsxFiles(new JsxFileOptions());
+        }
+
+        /// <summary>
+        /// Enables serving static JSX file, compiled to JavaScript with the given options.
+        /// </summary>
+        public static IAppBuilder UseJsxFiles(this IAppBuilder builder, JsxFileOptions options)
+        {
+            return builder.Use<JsxFileMiddleware>(options);
+        }
+    }
+}

src/React.Owin/JsxFileMiddleware.cs

@@ -0,0 +1,71 @@
+/*
+ *  Copyright (c) 2014-2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant 
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+using Microsoft.Owin.StaticFiles;
+
+namespace React.Owin
+{
+    /// <summary>
+    /// Enables serving static JSX files transformed to pure JavaScript. Wraps around StaticFileMiddleware.
+    /// </summary>
+    public class JsxFileMiddleware
+    {
+        private readonly StaticFileMiddleware _internalStaticMiddleware;
+
+        static JsxFileMiddleware()
+        {
+            Initializer.Initialize(_ => _);
+
+            // Register interface implementations required by React. By default it sets React to work with physical file system.
+            var container = AssemblyRegistration.Container;
+            IFileSystem tempFileSystem;
+            if (!container.TryResolve(out tempFileSystem))
+                AssemblyRegistration.Container.Register<IFileSystem, EntryAssemblyFileSystem>();
+
+            ICache tempCache;
+            if (!container.TryResolve(out tempCache))
+                AssemblyRegistration.Container.Register<ICache, MemoryFileCache>();
+        }
+
+        public JsxFileMiddleware(Func<IDictionary<string, object>, Task> next, JsxFileOptions options)
+        {
+            if (next == null)
+                throw new ArgumentNullException("next");
+
+            // Default values
+            options = options ?? new JsxFileOptions();
+            var extenstions = (options.Extensions == null || !options.Extensions.Any()) ? new[] { ".jsx" } : options.Extensions;
+            var fileOptions = options.StaticFileOptions ?? new StaticFileOptions();
+
+            // Wrap the file system with JSX file system
+            var reactEnvironment = 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, extenstions)
+                });
+        }
+
+        public Task Invoke(IDictionary<string, object> environment)
+        {
+            return _internalStaticMiddleware.Invoke(environment);
+        }
+    }
+}

src/React.Owin/JsxFileOptions.cs

@@ -0,0 +1,31 @@
+/*
+ *  Copyright (c) 2014-2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant 
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using System.Collections.Generic;
+
+using Microsoft.Owin.StaticFiles;
+
+namespace React.Owin
+{
+    /// <summary>
+    /// Options for serving JSX files.
+    /// </summary>
+    public class JsxFileOptions
+    {
+        /// <summary>
+        /// Collection of extensions that will be treated as JSX files. Defaults to ".jsx".
+        /// </summary>
+        public IEnumerable<string> Extensions { get; set; }
+
+        /// <summary>
+        /// Options for static file middle used to server JSX files.
+        /// </summary>
+        public StaticFileOptions StaticFileOptions { get; set; }
+    }
+}

src/React.Owin/JsxFileSystem.cs

@@ -0,0 +1,112 @@
+/*
+ *  Copyright (c) 2014-2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant 
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+using Microsoft.Owin.FileSystems;
+
+namespace React.Owin
+{
+    /// <summary>
+    /// Owin file system that serves transformed JSX files.
+    /// </summary>
+    internal class JsxFileSystem : Microsoft.Owin.FileSystems.IFileSystem
+    {
+        private readonly IJsxTransformer _transformer;
+        private readonly Microsoft.Owin.FileSystems.IFileSystem _physicalFileSystem;
+        private readonly string[] _extenstions;
+
+        public JsxFileSystem(IJsxTransformer transformer, string root, IEnumerable<string> extenstions)
+            : this(transformer, new PhysicalFileSystem(root), extenstions)
+        {            
+        }
+
+        public JsxFileSystem(IJsxTransformer transformer, Microsoft.Owin.FileSystems.IFileSystem fileSystem, IEnumerable<string> extenstions)
+        {
+            _transformer = transformer;
+            _physicalFileSystem = fileSystem;
+
+            // Make sure the extensions start with dot
+            _extenstions = extenstions.Select(extenstion => extenstion.StartsWith(".") ? extenstion : "." + extenstion).ToArray();
+        }
+
+        public bool TryGetFileInfo(string subpath, out IFileInfo fileInfo)
+        {
+            IFileInfo internalFileInfo;
+            fileInfo = null;
+
+            if (!_physicalFileSystem.TryGetFileInfo(subpath, out internalFileInfo))
+                return false;
+
+            if (internalFileInfo.IsDirectory || !_extenstions.Any(internalFileInfo.Name.EndsWith))
+                return false;
+
+            fileInfo = new JsxFileInfo(_transformer, internalFileInfo);
+            return true;
+        }
+
+        public bool TryGetDirectoryContents(string subpath, out IEnumerable<IFileInfo> contents)
+        {
+            return _physicalFileSystem.TryGetDirectoryContents(subpath, out contents);
+        }
+
+        private class JsxFileInfo : IFileInfo
+        {
+            private readonly IJsxTransformer _jsxTransformer;
+            private readonly IFileInfo _fileInfo;
+            private readonly Lazy<byte[]> _content;
+
+            public JsxFileInfo(IJsxTransformer jsxTransformer, IFileInfo fileInfo)
+            {
+                _jsxTransformer = jsxTransformer;
+                _fileInfo = fileInfo;
+
+                _content = new Lazy<byte[]>(
+                    () =>
+                    {
+                        return Encoding.UTF8.GetBytes(_jsxTransformer.TransformJsxFile(fileInfo.PhysicalPath));
+                    });
+            }
+
+            public Stream CreateReadStream()
+            {
+                return new MemoryStream(_content.Value);
+            }
+
+            public long Length
+            {
+                get { return _content.Value.Length; }
+            }
+
+            public string PhysicalPath
+            {
+                get { return _fileInfo.PhysicalPath; }
+            }
+
+            public string Name
+            {
+                get { return _fileInfo.Name; }
+            }
+
+            public DateTime LastModified
+            {
+                get { return _fileInfo.LastModified; }
+            }
+
+            public bool IsDirectory
+            {
+                get { return _fileInfo.IsDirectory; }
+            }
+        }
+    }
+}

src/React.Owin/MemoryFileCache.cs

@@ -0,0 +1,53 @@
+/*
+ *  Copyright (c) 2014-2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant 
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Caching;
+
+namespace React.Owin
+{
+    /// <summary>
+    /// Memory cache implementation for React.Owin.ICache. Uses System.Runtime.Caching.
+    /// </summary>
+    internal class MemoryFileCache : ICache
+    {
+        private readonly ObjectCache _cache;
+
+        public MemoryFileCache()
+        {
+            _cache = MemoryCache.Default;
+        }
+
+        public T Get<T>(string key, T fallback = default(T))
+        {
+            return (T)_cache.Get(key);
+        }
+
+        public void Set<T>(string key, T data, TimeSpan slidingExpiration, IEnumerable<string> cacheDependencyFiles = null, IEnumerable<string> cacheDependencyKeys = null)
+        {
+            if (data == null)
+            {
+                _cache.Remove(key);
+                return;
+            }
+
+            var policy = new CacheItemPolicy { SlidingExpiration = slidingExpiration };
+
+            if (cacheDependencyFiles != null && cacheDependencyFiles.Any())
+                policy.ChangeMonitors.Add(new HostFileChangeMonitor(cacheDependencyFiles.ToList()));
+
+            if (cacheDependencyKeys != null && cacheDependencyKeys.Any())
+                policy.ChangeMonitors.Add(_cache.CreateCacheEntryChangeMonitor(cacheDependencyKeys));
+
+            _cache.Set(key, data, policy);
+        }
+    }
+}

src/React.Owin/Properties/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("React.Owin")]
+[assembly: AssemblyDescription("Owin integration for ReactJS.NET")]
+[assembly: ComVisible(false)]
+[assembly: Guid("7f0500f5-5a9f-48c9-b136-41cfd1787724")]