Remove auto-registered JS engines from React.Core (#582)

* Remove auto-registered JS engines from React.Core

* Update docs

* Update samples

* Fix cassette build

* Fix building Cassette sample in release mode

* Remove unused code

* Add missing reference

* Fix Cassette sample build

* Fix code block syntax

* Fix language hint

* Update error handling and add some tests

Author: dustinsoftware

site/jekyll/getting-started/aspnet.md

@@ -0,0 +1,58 @@
+---
+id: aspnet
+layout: docs
+title: Getting Started on ASP.NET
+---
+
+This guide covers enabling server-side rendering and Babel compilation. If you want a step-by-step guide on configuring a brand new site, see [the ReactJS.NET tutorial for ASP.NET](/getting-started/tutorial_aspnet4.html).
+
+ReactJS.NET requires Visual Studio 2015 and MVC 4 or 5.
+
+Install the `React.Web.Mvc4` package through NuGet. You will also need to install a JS engine to use (either V8 or ChakraCore are recommended). See the [JSEngineSwitcher docs](https://github.com/Taritsyn/JavaScriptEngineSwitcher/wiki/Registration-of-JS-engines) for more information.
+
+To use V8, add the following packages:
+
+```
+JavaScriptEngineSwitcher.V8
+JavaScriptEngineSwitcher.V8.Native.win-x64
+```
+
+`ReactConfig.cs` will be automatically generated for you. Update it to register a JS engine and your JSX files:
+
+```csharp
+using JavaScriptEngineSwitcher.Core;
+using JavaScriptEngineSwitcher.V8;
+
+[assembly: WebActivatorEx.PreApplicationStartMethod(typeof(React.Sample.Mvc4.ReactConfig), "Configure")]
+
+namespace React.Sample.Mvc4
+{
+	public static class ReactConfig
+	{
+		public static void Configure()
+		{
+			ReactSiteConfiguration.Configuration
+				.AddScript("~/Content/Sample.jsx");
+
+			JsEngineSwitcher.Current.DefaultEngineName = V8JsEngine.EngineName;
+			JsEngineSwitcher.Current.EngineFactories.AddV8();
+		}
+	}
+}
+```
+
+Reference JSX files directly in script tags:
+
+```html
+<script src="~/Content/Sample.jsx"></script>
+```
+
+You're done! You can now call `Html.React` from within Razor files:
+
+```
+@Html.React("Sample", new { initialComments = Model.Comments, page = Model.Page })
+```
+
+You can also use [webpack](/guides/webpack.html) or [System.Web.Optimization](/guides/weboptimizer.html) to bundle your scripts together.
+
+Check out the [sample project](https://github.com/reactjs/React.NET/tree/master/src/React.Sample.Mvc4) for a working demo.

site/jekyll/getting-started/aspnetcore.md

@@ -4,14 +4,18 @@ layout: docs
 title: Getting Started on ASP.NET Core
 ---
 
-Getting started with ReactJS.NET on ASP.NET Core requires a few more steps compared to previous versions of ASP.NET and MVC. If you want a step-by-step guide on configuring a brand new site, see [the ReactJS.NET tutorial for ASP.NET Core](/getting-started/tutorial.html).
+This guide covers enabling server-side rendering and Babel compilation. Getting started with ReactJS.NET on ASP.NET Core requires a few more steps compared to previous versions of ASP.NET and MVC. If you want a step-by-step guide on configuring a brand new site, see [the ReactJS.NET tutorial for ASP.NET Core](/getting-started/tutorial.html).
 
 ReactJS.NET requires Visual Studio 2015 and ASP.NET Core RTM (final release). It is recommended to use .NET Framework, but ReactJS.NET also works with .NET Core.
 
-Install the `React.AspNet` package through NuGet. After the package is installed, ReactJS.NET needs to be initialised in your `Startup.cs` file (unfortunately this can not be done automatically like in previous versions of ASP.NET with WebActivator). At the top of the file, add:
+Install the `React.AspNet` package through NuGet.  You will also need to install a JS engine to use (either V8 or ChakraCore are recommended). See the [JSEngineSwitcher docs](https://github.com/Taritsyn/JavaScriptEngineSwitcher/wiki/Registration-of-JS-engines) for more information. After these packages are installed, ReactJS.NET needs to be initialised in your `Startup.cs` file (unfortunately this can not be done automatically like in previous versions of ASP.NET with WebActivator).
+
+At the top of Startup.cs, add:
 
 ```
 using Microsoft.AspNetCore.Http;
+using JavaScriptEngineSwitcher.Core;
+using JavaScriptEngineSwitcher.ChakraCore;
 using React.AspNet;
 ```
 
@@ -27,6 +31,10 @@ Add:
 ```csharp
 services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
 services.AddReact();
+
+// Make sure a JS engine is registered, or you will get an error!
+services.AddJsEngineSwitcher(options => options.DefaultEngineName = ChakraCoreJsEngine.EngineName)
+  .AddChakraCore();
 ```
 
 
@@ -66,6 +74,18 @@ Finally, add this to `Views\_ViewImports.cshtml` (or create it if it doesn't exi
 @using React.AspNet
 ```
 
-Once ReactJS.NET has been configured, you will be able to use [on-the-fly JSX to JavaScript compilation](/getting-started/usage.html) and [server-side rendering](/guides/server-side-rendering.html).
+Reference JSX files directly in script tags:
+
+```html
+<script src="~/Content/Sample.jsx"></script>
+```
+
+You're done! You can now call `Html.React` from within Razor files:
+
+```
+@Html.React("Sample", new { initialComments = Model.Comments, page = Model.Page })
+```
 
 If you need support for non-Windows platforms, please see the [ChakraCore guide](/guides/chakracore.html).
+
+Check out the [sample project](https://github.com/reactjs/React.NET/tree/master/src/React.Sample.CoreMvc) for a working demo.

site/jekyll/getting-started/tutorial.md

@@ -201,15 +201,15 @@ If you see this, congratulations! You've just built your first React component.
 The first thing you'll notice is the XML-ish syntax in your JavaScript. We have a simple precompiler that translates the syntactic sugar to this plain JavaScript:
 
 ```javascript
-var CommentBox = React.createClass({displayName: 'CommentBox',
-  render: function() {
+class CommentBox extends React.Component {
+  render() {
     return (
       React.createElement('div', {className: "commentBox"},
         "Hello, world! I am a CommentBox."
       )
     );
   }
-});
+};
 
 ReactDOM.render(
   React.createElement(CommentBox, null),

site/jekyll/getting-started/tutorial_aspnet4.md

@@ -126,15 +126,15 @@ If you see this, congratulations! You've just built your first React component.
 The first thing you'll notice is the XML-ish syntax in your JavaScript. We have a simple precompiler that translates the syntactic sugar to this plain JavaScript:
 
 ```javascript
-var CommentBox = React.createClass({displayName: 'CommentBox',
-  render: function() {
+class CommentBox extends React.Component {
+  render() {
     return (
       React.createElement('div', {className: "commentBox"},
         "Hello, world! I am a CommentBox."
       )
     );
   }
-});
+};
 
 ReactDOM.render(
   React.createElement(CommentBox, null),

site/jekyll/getting-started/usage.md

@@ -7,13 +7,13 @@ Once installed, create your React components as usual.
 
 ```javascript
 // /Scripts/HelloWorld.jsx
-var HelloWorld = React.createClass({
-	render: function () {
+class HelloWorld extends React.Component {
+	render() {
 		return (
 			<div>Hello {this.props.name}</div>
 		);
 	}
-});
+}
 ```
 
 On-the-Fly JSX to JavaScript Compilation

site/jekyll/guides/azure.md

@@ -28,14 +28,14 @@ var OldAndBusted = React.createClass({
 });
 
 // The new way
-var NewHotness = React.createClass({
+class NewHotness extends React.Component {
   render() {
     // ...
   },
   doStuff() {
     // ...
   }
-});
+};
 ```
 
 * **[Classes](http://wiki.ecmascript.org/doku.php?id=strawman:maximally_minimal_classes)** — Similar to the class systems included in JavaScript frameworks such as Prototype and MooTools, but will (eventually) be native to JavaScript

site/jekyll/guides/es6.md

@@ -3,31 +3,8 @@ layout: docs
 title: Linux (Mono)
 ---
 
-ReactJS.NET includes full support for Mono via Google's [V8 JavaScript engine](https://code.google.com/p/v8/), the same engine used by Google Chrome and Node.js. To use ReactJS.NET with Mono, you need to compile V8 and VroomJs (a .NET wrapper around V8). This can be accomplished by running the following shell commands on your Linux or Mac OS X machine:
+While Mono is supported, we strongly recommend using .NET Core instead.
 
-```sh
-# Get a supported version of V8
-cd /usr/local/src/
-git clone https://github.com/v8/v8.git v8-3.17
-cd v8-3.17
-git checkout tags/3.17.16.2
-
-# Build V8
-make dependencies
-make native werror=no library=shared soname_version=3.17.16.2 -j4
-cp out/native/lib.target/libv8.so.3.17.16.2 /usr/local/lib/
-
-# Get ReactJS.NET's version of libvroomjs
-cd /usr/local/src/
-git clone https://github.com/reactjs/react.net.git
-cd react.net
-git submodule update --init
-cd lib/VroomJs/libvroomjs/
-
-# Build libvroomjs
-g++ jscontext.cpp jsengine.cpp managedref.cpp bridge.cpp jsscript.cpp -o libVroomJsNative.so -shared -L /usr/local/src/v8-3.17/out/native/lib.target/ -I /usr/local/src/v8-3.17/include/ -fPIC -Wl,--no-as-needed -l:/usr/local/lib/libv8.so.3.17.16.2
-cp libVroomJsNative.so /usr/local/lib/
-ldconfig
-```
+ReactJS.NET includes full support for Mono via Google's [V8 JavaScript engine](https://code.google.com/p/v8/), the same engine used by Google Chrome and Node.js. To use ReactJS.NET with Mono, follow the documentation on the [JavaScriptEngineSwitcher repo](https://github.com/Taritsyn/JavaScriptEngineSwitcher/wiki/JS-Engine-Switcher:-Vroom) to build Vroom, and then register the JS Engine as the default in `Startup.cs`. For example on how to do this, see the [ChakraCore guide](/guides/chakracore.html).
 
 If VroomJs fails to load, you will see an exception when your application is started. If this happens, run Mono with the `MONO_LOG_LEVEL=debug` environment variable to get more useful debugging information. Often, this occurs when Mono is unable to locate V8 (ie. it's not in /usr/lib/ or /usr/local/lib/)

site/jekyll/guides/mono.md

@@ -3,6 +3,8 @@ layout: docs
 title: Webpack
 ---
 
+This guide is for Webpack 1. To see the latest example for how to use webpack, check out the [sample project](https://github.com/reactjs/React.NET/tree/master/src/React.Sample.Webpack).
+
 [Webpack](http://webpack.github.io/docs/what-is-webpack.html) is a popular module bundling system built on top of Node.js. It can handle not only combination and minification of JavaScript and CSS files, but also other assets such as image files (spriting) through the use of plugins. Webpack can be used as an alternative to Cassette or ASP.NET Combination and Minification. This guide assumes you have already [installed Webpack](http://webpack.github.io/docs/installation.html).
 
 In order to use Webpack with ReactJS.NET's server-side rendering, it is suggested that you create a separate bundle ("[entry point](http://webpack.github.io/docs/multiple-entry-points.html)") containing *only* the code required to perform server-side rendering. Any components you would like to render server-side must be exposed globally so that ReactJS.NET can access them. This can be done through the [Webpack expose loader](https://github.com/webpack/expose-loader):

site/jekyll/guides/webpack.md

@@ -48,11 +48,11 @@ id: home
 
 ```javascript
 // /Scripts/HelloWorld.jsx
-var HelloWorld = React.createClass({
+class HelloWorld extends React.Component {
   render: function() {
     return <div>Hello world!</div>;
   }
-});
+}
 ```
 ```html
 <!-- Reference it from HTML -->