0.4.2

I found it weird how the es5-shim comment came after the list of functions; now it's before.

.travis.yml

@@ -1,3 +1,14 @@
+---
 language: node_js
 node_js:
-  - "0.10"
+- '0.10'
+after_script:
+- curl -F "react=@build/react.js" -F "react.min=@build/react.min.js" -F "transformer=@build/JSXTransformer.js"
+  -F "commit=$TRAVIS_COMMIT" -F "date=`git log --format='%ct' -1`" -F "pull_request=$TRAVIS_PULL_REQUEST"
+  -F "token=$SECRET_TOKEN" -F "branch=$TRAVIS_BRANCH" $SERVER
+env:
+  global:
+  # SERVER
+  - secure: qPvsJ46XzGrdIuPA70b55xQNGF8jcK7N1LN5CCQYYocXLa+fBrl+fTE77QvehOPhqwJXcj6kOxI+sY0KrVwV7gmq2XY2HZGWUSCxTN0SZlNIzqPA80Y7G/yOjA4PUt8LKgP+8tptyhTAY56qf+hgW8BoLiKOdztYF2p+3zXOLuA=
+  # SECRET_TOKEN
+  - secure: dkpPW+VnoqC/okhRdV90m36NcyBFhcwEKL3bNFExAwi0dXnFao8RoFlvnwiPlA23h2faROkMIetXlti6Aju08BgUFV+f9aL6vLyU7gUent4Nd3413zf2fwDtXIWIETg6uLnOpSykGKgCAT/hY3Q2oPLqOoY0OxfgnbqwxkxljrE=

CHANGELOG.md

@@ -1,3 +1,19 @@
+## 0.4.1 (July 26, 2013)
+
+### React
+
+* `setState` callbacks are now executed in the scope of your component.
+* `click` events now work on Mobile Safari.
+* Prevent a potential error in event handling if `Object.prototype` is extended.
+* Don't set DOM attributes to the string `"undefined"` on update when previously defined.
+* Improved support for `<iframe>` attributes.
+* Added checksums to detect and correct cases where server-side rendering markup mismatches what React expects client-side.
+
+### JSXTransformer
+
+* Improved environment detection so it can be run in a non-browser environment.
+
+
 ## 0.4.0 (July 17, 2013)
 
 ### React
@@ -16,7 +32,7 @@
 
 * Support for comment nodes `<div>{/* this is a comment and won't be rendered */}</div>`
 * Children are now transformed directly into arguments instead of being wrapped in an array
-  E.g. `<div><Component1/><Component2></div>` is transformed into `React.DOM.div(null, Component1(null), Component2(null))`.
+  E.g. `<div><Component1/><Component2/></div>` is transformed into `React.DOM.div(null, Component1(null), Component2(null))`.
   Previously this would be transformed into `React.DOM.div(null, [Component1(null), Component2(null)])`.
   If you were using React without JSX previously, your code should still work.
 

README.md

@@ -32,16 +32,16 @@ You'll notice that we used an XML-like syntax; [we call it JSX](http://facebook.
 
 ## Installation
 
-The fastest way to get started is to serve JavaScript from the CDN:
+The fastest way to get started is to serve JavaScript from the CDN (also available on [CDNJS](http://cdnjs.com/#react)):
 
 ```html
 <!-- The core React library -->
-<script src="http://fb.me/react-0.3.2.min.js"></script>
+<script src="http://fb.me/react-0.4.1.min.js"></script>
 <!-- In-browser JSX transformer, remove when pre-compiling JSX. -->
-<script src="http://fb.me/JSXTransformer-0.3.2.js"></script>
+<script src="http://fb.me/JSXTransformer-0.4.1.js"></script>
 ```
 
-We've also built a [starter kit](http://facebook.github.io/react/downloads/react-0.3.2.zip) which might be useful if this is your first time using React. It includes a webpage with an example of using React with live code.
+We've also built a [starter kit](http://facebook.github.io/react/downloads/react-0.4.1.zip) which might be useful if this is your first time using React. It includes a webpage with an example of using React with live code.
 
 If you'd like to use [bower](http://bower.io), it's as easy as:
 

bin/jsx

@@ -41,6 +41,7 @@ require("commoner").resolve(function(id) {
     return context.getProvidedP().then(function(idToPath) {
       if (id !== "mock-modules" &&
           id !== "mocks" &&
+          id !== "test/all" &&
           idToPath.hasOwnProperty("mock-modules")) {
         return source + '\nrequire("mock-modules").register(' +
           JSON.stringify(id) + ', module);\n';

docs/Gemfile

@@ -1,5 +1,7 @@
 source 'https://rubygems.org'
 
+gem 'rake'
+
 # jekyll, which builds it all
 gem 'jekyll', '~>1.0'
 
@@ -14,3 +16,6 @@ gem 'rb-fsevent'
 
 # Redcarpet for Markdown
 gem 'redcarpet'
+
+# For markdown header cleanup
+gem 'sanitize'

docs/Gemfile.lock

@@ -24,13 +24,19 @@ GEM
     liquid (2.5.0)
     maruku (0.6.1)
       syntax (>= 1.0.0)
+    mini_portile (0.5.1)
+    nokogiri (1.6.0)
+      mini_portile (~> 0.5.0)
     posix-spawn (0.3.6)
     pygments.rb (0.5.0)
       posix-spawn (~> 0.3.6)
       yajl-ruby (~> 1.1.0)
+    rake (10.0.4)
     rb-fsevent (0.9.3)
     redcarpet (2.2.2)
     safe_yaml (0.7.1)
+    sanitize (2.0.6)
+      nokogiri (>= 1.4.4)
     sass (3.2.9)
     syntax (1.0.0)
     yajl-ruby (1.1.0)
@@ -41,6 +47,8 @@ PLATFORMS
 DEPENDENCIES
   jekyll (~> 1.0)
   json
+  rake
   rb-fsevent
   redcarpet
+  sanitize
   sass

docs/Rakefile

@@ -13,7 +13,7 @@ task :js do
 end
 
 desc "watch css & js"
-task :watch => [:update_version] do
+task :watch do
   Process.spawn "sass --style=compressed --watch _css/react.scss:css/react.css"
   Process.spawn "../bin/jsx --watch _js js"
   Process.waitall
@@ -30,8 +30,8 @@ task :update_version do
 end
 
 desc "build into ../../react-gh-pages"
-task :release => [:default] do
+task :release => [:update_version, :default] do
   system "jekyll build -d ../../react-gh-pages"
 end
 
-task :default => [:update_version, :css, :js]
+task :default => [:css, :js]

docs/_config.yml

@@ -13,9 +13,11 @@ redcarpet:
 pygments: true
 name: React
 markdown: redcarpet
-react_version: 0.4.0
+react_version: 0.4.2
 description: A JavaScript library for building user interfaces
 relative_permalinks: true
+paginate: 5
+paginate_path: /blog/page:num
 nav_docs_sections:
 - title: Quick Start
   items:
@@ -48,6 +50,20 @@ nav_docs_sections:
     - id: more-about-refs
       title: More About Refs
   - id: tooling-integration
-    title: Tooling integration
-  - id: reference
-    title: Reference
+    title: Tooling Integration
+  - id: examples
+    title: Examples
+- title: Reference
+  items:
+  - id: top-level-api
+    title: Top-Level API
+  - id: component-api
+    title: Component API
+  - id: component-specs
+    title: Component Specs and Lifecycle
+  - id: tags-and-attributes
+    title: Supported Tags and Attributes
+  - id: events
+    title: Event System
+  - id: dom-differences
+    title: DOM Differences

docs/_css/react.scss

@@ -199,8 +199,7 @@ li {
   font-size: 14px;
   // position: fixed;
   float: left;
-  top: 100px;
-  width: 180px;
+  width: 210px;
 
   ul {
     list-style: none;
@@ -248,6 +247,12 @@ li {
 
 }
 
+.nav-blog {
+  li {
+    margin-bottom: 5px;
+  }
+}
+
 // Home Page specifics
 
 .home-section {
@@ -285,14 +290,14 @@ li {
   margin-right: 0;
 }
 
-#examples {
-  h3 {
-    color: $darkColor;
-    font-size: 24px;
-    font-weight: normal;
-    margin-bottom: 5px;
-  }
+#examples h3, .home-presentation h3 {
+  color: $darkColor;
+  font-size: 24px;
+  font-weight: normal;
+  margin-bottom: 5px;
+}
 
+#examples {
   p {
     margin: 0 0 25px 0;
     max-width: $twoColumnWidth;
@@ -685,3 +690,15 @@ p code {
 .post {
   margin-bottom: 30px;
 }
+
+.pagination {
+  margin-bottom: 30px;
+
+  /* Trick to get the wrapper to expand to fit floating elements */
+  width: 100%;
+  overflow: hidden;
+
+  .next {
+    float: right;
+  }
+}

docs/_includes/nav_blog.html

@@ -1,10 +1,11 @@
-<div class="nav-docs">
+<div class="nav-docs nav-blog">
   <div class="nav-docs-section">
     <h3>Recent posts</h3>
     <ul>
-    {% for post in site.posts %}
-      <li><a href="/react{{ post.url }}"{% if page.title == post.title %} class="active"{% endif %}>{{ post.title }}</a></li>
-    {% endfor %}
+      {% for post in site.posts limit:10 %}
+        <li><a href="/react{{ post.url }}"{% if page.title == post.title %} class="active"{% endif %}>{{ post.title }}</a></li>
+      {% endfor %}
+      <li><a href="/react/blog/all.html">All posts ...</a></li>
     </ul>
   </div>
 </div>

docs/_js/examples/markdown.js

@@ -11,16 +11,17 @@ var MarkdownEditor = React.createClass({\n\
   getInitialState: function() {\n\
     return {value: 'Type some *markdown* here!'};\n\
   },\n\
-  handleInput: function() {\n\
+  handleChange: function() {\n\
     this.setState({value: this.refs.textarea.getDOMNode().value});\n\
   },\n\
   render: function() {\n\
     return (\n\
       <div className=\"MarkdownEditor\">\n\
         <h3>Input</h3>\n\
-        <textarea onInput={this.handleInput} ref=\"textarea\">\n\
-          {this.state.value}\n\
-        </textarea>\n\
+        <textarea\n\
+          onChange={this.handleChange}\n\
+          ref=\"textarea\"\n\
+          defaultValue={this.state.value} />\n\
         <h3>Output</h3>\n\
         <div\n\
           className=\"content\"\n\

docs/_js/examples/timer.js

@@ -11,7 +11,10 @@ var Timer = React.createClass({\n\
     this.setState({secondsElapsed: this.state.secondsElapsed + 1});\n\
   },\n\
   componentDidMount: function() {\n\
-    setInterval(this.tick, 1000);\n\
+    this.interval = setInterval(this.tick, 1000);\n\
+  },\n\
+  componentWillUnmount: function() {\n\
+    clearInterval(this.interval);\n\
   },\n\
   render: function() {\n\
     return React.DOM.div({},\n\

docs/_js/examples/todo.js

@@ -16,7 +16,7 @@ var TodoApp = React.createClass({\n\
   getInitialState: function() {\n\
     return {items: [], text: ''};\n\
   },\n\
-  onKey: function(e) {\n\
+  onChange: function(e) {\n\
     this.setState({text: e.target.value});\n\
   },\n\
   handleSubmit: function(e) {\n\
@@ -30,8 +30,8 @@ var TodoApp = React.createClass({\n\
       <div>\n\
         <h3>TODO</h3>\n\
         <TodoList items={this.state.items} />\n\
-        <form onSubmit={this.handleSubmit.bind(this)}>\n\
-          <input onKeyUp={this.onKey.bind(this)} value={this.state.text} />\n\
+        <form onSubmit={this.handleSubmit}>\n\
+          <input onChange={this.onChange} value={this.state.text} />\n\
           <button>{'Add #' + (this.state.items.length + 1)}</button>\n\
         </form>\n\
       </div>\n\

docs/_js/live_editor.js

@@ -24,7 +24,7 @@ var CodeMirrorEditor = React.createClass({
       matchBrackets: true,
       theme: 'solarized-light'
     });
-    this.editor.on('change', this.onChange.bind(this));
+    this.editor.on('change', this.onChange);
     this.onChange();
   },
   onChange: function() {
@@ -40,7 +40,7 @@ var CodeMirrorEditor = React.createClass({
     if (IS_MOBILE) {
       editor = <pre style={{overflow: 'scroll'}}>{this.props.codeText}</pre>;
     } else {
-      editor = <textarea ref="editor">{this.props.codeText}</textarea>;
+      editor = <textarea ref="editor" defaultValue={this.props.codeText} />;
     }
 
     return (

docs/_layouts/default.html

@@ -10,6 +10,7 @@
   <meta property="og:url" content="http://facebook.github.io/react{{ page.url }}" />
   <meta property="og:image" content="http://facebook.github.io/react/img/logo_og.png" />
   <meta property="og:description" content="A JavaScript library for building user interfaces" />
+  <meta property="fb:app_id" content="623268441017527" />
 
   <link rel="shortcut icon" href="/react/favicon.ico">
   <link rel="alternate" type="application/rss+xml" title="{{ site.name }}" href="{{ site.url }}{{ site.baseurl }}/feed.xml">

docs/_layouts/redirect.html

@@ -0,0 +1,6 @@
+<html>
+<head>
+  <meta http-equiv="refresh" content="0; {{ page.destination }}">
+</head>
+<body></body>
+</html>

docs/_plugins/header_links.rb

@@ -0,0 +1,17 @@
+require 'redcarpet'
+require 'sanitize'
+
+# Simple converter that is probably better than RedCarpet's built in TOC id
+# generator (which ends up with things lik id="toc_1"... terrible).
+
+class Redcarpet::Render::HTML
+  def header(title, level)
+    clean_title = Sanitize.clean(title)
+      .downcase
+      .gsub(/\s+/, "-")
+      .gsub(/[^A-Za-z0-9\-_.]/, "")
+
+    return "<h#{level} id=\"#{clean_title}\">#{title}</h#{level}>"
+  end
+end
+

docs/_posts/2013-06-05-why-react.md

@@ -20,8 +20,8 @@ These templates dictate the full set of abstractions that you are allowed to use
 to build your UI.
 
 React approaches building user interfaces differently by breaking them into
-**components**. This means React uses JavaScript to generate markup, which we
-see as an advantage over templates for a few reasons:
+**components**. This means React uses a real, full featured programming language
+to render views, which we see as an advantage over templates for a few reasons:
 
 - **JavaScript is a flexible, powerful programming language** with the ability
   to build abstractions. This is incredibly important in large applications.

docs/_posts/2013-06-27-community-roundup-3.md

@@ -8,7 +8,7 @@ The highlight of this week is that an interaction-heavy app has been ported to R
 
 ## Moving From Backbone To React
 
-[Clay Allsopp](http://twitter.com/clayallsopp) successfuly ported [Propeller](http://usepropeller.com/blog/posts/from-backbone-to-react/), a fairly big, interaction-heavy JavaScript app, to React.
+[Clay Allsopp](http://twitter.com/clayallsopp) successfully ported [Propeller](http://usepropeller.com/blog/posts/from-backbone-to-react/), a fairly big, interaction-heavy JavaScript app, to React.
 
 > [<img style="float: right; margin: 0 0 10px 10px;" src="/react/img/blog/propeller-logo.png" />](http://usepropeller.com/blog/posts/from-backbone-to-react/)Subviews involve a lot of easy-to-forget boilerplate that Backbone (by design) doesn't automate. Libraries like Backbone.Marionette offer more abstractions to make view nesting easier, but they're all limited by the fact that Backbone delegates how and went view-document attachment occurs to the application code.
 >

docs/_posts/2013-07-03-community-roundup-4.md

@@ -23,7 +23,7 @@ The best part is the demo of how React reconciliation process makes live editing
 
 ## React Snippets
 
-Over the past several weeks, members of our team, [Pete Hunt](http://www.petehunt.net/) and [Paul O'Shannessy](http://zpao.com/), answered many questions that were asked in the [React group](https://groups.google.com/forum/#!forum/reactjs). They give a good overview of how to integrate React with other libraries and APIs through the use of [Mixins](/react/docs/mixins.html) and [Lifecycle Methods](/react/docs/advanced-components.html).
+Over the past several weeks, members of our team, [Pete Hunt](http://www.petehunt.net/) and [Paul O'Shannessy](http://zpao.com/), answered many questions that were asked in the [React group](https://groups.google.com/forum/#!forum/reactjs). They give a good overview of how to integrate React with other libraries and APIs through the use of [Mixins](/react/docs/reusable-components.html) and [Lifecycle Methods](/react/docs/working-with-the-browser.html).
 
 > [Listening Scroll Event](https://groups.google.com/forum/#!topic/reactjs/l6PnP8qbofk)
 >

docs/_posts/2013-07-17-react-v0-4-0.md

@@ -4,7 +4,7 @@ layout: post
 author: Paul O'Shannessy
 ---
 
-Over the past 2 months we've been taking feedback and working hard to make React even better. We've also added several features that awe didn't finish in time for the v0.3 launch, and are proud to announce the availability of React v0.4 today!
+Over the past 2 months we've been taking feedback and working hard to make React even better. We fixed some bugs, made some under-the-hood improvements, and added several features that we think will improve the experience developing with React. Today we're proud to announce the availability of React v0.4!
 
 
 This release could not have happened without the support of our growing community. Since launch day, the community has contributed blog posts, questions to the [Google Group](http://groups.google.com/group/reactjs), and issues and pull requests on GitHub. We've had contributions ranging from documentation improvements to major changes to React's rendering. We've seen people integrate React into the tools they're using and the products they're building, and we're all very excited to see what our budding community builds next!
@@ -24,13 +24,13 @@ When you're ready, [go download it](/react/downloads.html)!
 * Removed `React.autoBind`. [Read our blog post for details...](http://facebook.github.io/react/blog/2013/07/02/react-v0-4-autobind-by-default.html)
 * Improvements to forms. We've written wrappers around `<input>`, `<textarea>`, `<option>`, and `<select>` in order to standardize many inconsistencies in browser implementations. This includes support for `defaultValue`, and improved implementation of the `onChange` event, and circuit completion. [Read the docs for details...](http://facebook.github.io/react/docs/forms.html)
 * We've implemented an improved synthetic event system that conforms to the W3C spec.
-* Updates to your component are batched now, which may result in a significantly faster re-render of components. `this.setState` now takes an optional callback as it's second parameter. If you were using `onClick={this.setState.bind(this, state)}` previously, you'll want to make sure you add a third parameter so that the event is not treated as the callback.
+* Updates to your component are batched now, which may result in a significantly faster re-render of components. `this.setState` now takes an optional callback as its second parameter. If you were using `onClick={this.setState.bind(this, state)}` previously, you'll want to make sure you add a third parameter so that the event is not treated as the callback.
 
 ### JSX
 
 * Support for comment nodes `<div>{/* this is a comment and won't be rendered */}</div>`
 * Children are now transformed directly into arguments instead of being wrapped in an array
-  E.g. `<div><Component1/><Component2></div>` is transformed into `React.DOM.div(null, Component1(null), Component2(null))`.
+  E.g. `<div><Component1/><Component2/></div>` is transformed into `React.DOM.div(null, Component1(null), Component2(null))`.
   Previously this would be transformed into `React.DOM.div(null, [Component1(null), Component2(null)])`.
   If you were using React without JSX previously, your code should still work.
 

docs/_posts/2013-07-23-community-roundup-5.md

@@ -0,0 +1,99 @@
+---
+title: "Community Round-up #5"
+layout: post
+author: Vjeux
+---
+
+We launched the [React Facebook Page](https://www.facebook.com/react) along with the React v0.4 launch. 700 people already liked it to get updated on the project :)
+
+## Cross-browser onChange
+
+[Ben Alpert](http://benalpert.com/) from [Khan Academy](https://www.khanacademy.org/) worked on a cross-browser implementation of `onChange` event that landed in v0.4. He wrote a blog post explaining the various browser quirks he had to deal with.
+
+> First off, what is the input event? If you have an `<input>` element and want to receive events whenever the value changes, the most obvious thing to do is to listen to the change event. Unfortunately, change fires only after the text field is defocused, rather than on each keystroke. The next obvious choice is the keyup event, which is triggered whenever a key is released. Unfortunately, keyup doesn't catch input that doesn't involve the keyboard (e.g., pasting from the clipboard using the mouse) and only fires once if a key is held down, rather than once per inserted character.
+>
+> Both keydown and keypress do fire repeatedly when a key is held down, but both fire immediately before the value changes, so to read the new value you have to defer the handler to the next event loop using `setTimeout(fn, 0)` or similar, which slows down your app. Of course, like keyup, neither keydown nor keypress fires for non-keyboard input events, and all three can fire in cases where the value doesn't change at all (such as when pressing the arrow keys).
+>
+> [Read the full post...](http://benalpert.com/2013/06/18/a-near-perfect-oninput-shim-for-ie-8-and-9.html)
+
+
+## React Samples
+
+Learning a new library is always easier when you have working examples you can play with. [jwh](https://github.com/jhw) put many of them on his [react-samples Github repo](https://github.com/jhw/react-samples).
+
+> Some simple examples with Facebook's React framework
+>
+> * Bootstrap action bar, modal and table [#1](https://rawgithub.com/jhw/react-samples/master/html/actionbar.html),
+> [#2](https://rawgithub.com/jhw/react-samples/master/html/bootstrap_actionbar.html),
+> [#3](https://rawgithub.com/jhw/react-samples/master/html/bootstrap_modal.html),
+> [#4](https://rawgithub.com/jhw/react-samples/master/html/bootstrap_striped_table.html)
+> * Comments [#1](https://rawgithub.com/jhw/react-samples/master/html/comments1.html),
+> [#2](https://rawgithub.com/jhw/react-samples/master/html/comments2.html)
+> * Data Table [#1](https://rawgithub.com/jhw/react-samples/master/html/datatable.html),
+> [#2](https://rawgithub.com/jhw/react-samples/master/html/datatable2.html),
+> [#3](https://rawgithub.com/jhw/react-samples/master/html/datatable3.html),
+> [#4](https://rawgithub.com/jhw/react-samples/master/html/datatable4.html),
+> [#5](https://rawgithub.com/jhw/react-samples/master/html/datatable5.html)
+> * Filter Bar [#1](https://rawgithub.com/jhw/react-samples/master/html/filterbar.html),
+> [#2](https://rawgithub.com/jhw/react-samples/master/html/filterbar2.html),
+> [#3](https://rawgithub.com/jhw/react-samples/master/html/filterbar3.html),
+> [#4](https://rawgithub.com/jhw/react-samples/master/html/filterbar4.html),
+> [#5](https://rawgithub.com/jhw/react-samples/master/html/filterbar5.html)
+> * Fundoo Rating [#1](https://rawgithub.com/jhw/react-samples/master/html/fundoo.html)
+> * Line Char: [#1](https://rawgithub.com/jhw/react-samples/master/html/linechart.html),
+> [#2](https://rawgithub.com/jhw/react-samples/master/html/linechart2.html)
+> * Multi tabs [#1](https://rawgithub.com/jhw/react-samples/master/html/multitabs.html)
+> * Select [#1](https://rawgithub.com/jhw/react-samples/master/html/select.html)
+> * Simple Tabs [#1](https://rawgithub.com/jhw/react-samples/master/html/simpletabs.html),
+> [#2](https://rawgithub.com/jhw/react-samples/master/html/simpletabs2.html),
+> [#3](https://rawgithub.com/jhw/react-samples/master/html/simpletabs3.html),
+> [#4](https://rawgithub.com/jhw/react-samples/master/html/simpletabs4.html)
+> * Toggle [#1](https://rawgithub.com/jhw/react-samples/master/html/toggle.html)
+
+
+## React Chosen Wrapper
+
+[Cheng Lou](https://github.com/chenglou) wrote a wrapper for the [Chosen](http://harvesthq.github.io/chosen/) input library called [react-chosen](https://github.com/chenglou/react-chosen). It took just 25 lines to be able to use jQuery component as a React one.
+
+```javascript
+React.renderComponent(
+  <Chosen noResultsText="No result" value="Harvest" onChange={doSomething}>
+    <option value="Facebook">Facebook</option>
+    <option value="Harvest">Harvest</option>
+  </Chosen>
+, document.body);
+```
+
+
+## JSX and ES6 Template Strings
+
+[Domenic Denicola](http://domenicdenicola.com/) wrote a slide deck about the great applications of ES6 features and one slide shows how we could use Template Strings to compile JSX at run-time without the need for a pre-processing phase.
+
+<figure><iframe src="http://www.slideshare.net/slideshow/embed_code/24187146?rel=0&startSlide=36" width="600" height="356" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" style="border:1px solid #CCC;border-width:1px 1px 0;margin-bottom:5px" allowfullscreen webkitallowfullscreen mozallowfullscreen> </iframe></figure>
+
+
+## React Presentation
+
+[Tom Occhino](http://tomocchino.com/) and [Jordan Walke](https://github.com/jordwalke), React developers, did a presentation of React at Facebook Seattle's office. Check out the first 25 minutes for the presentation and the remaining 45 for a Q&A. I highly recommend you watching this video.
+
+<figure><iframe width="650" height="400" src="//www.youtube.com/embed/XxVg_s8xAms" frameborder="0" allowfullscreen></iframe></figure>
+
+
+## Docs
+
+[Pete Hunt](http://www.petehunt.net/) rewrote the entirety of the docs for v0.4. The goal was to add more explanation about why we built React and what the best practices are.
+
+> Guides
+>
+> * [Why React?](/react/docs/why-react.html)
+> * [Displaying Data](/react/docs/displaying-data.html)
+>   * [JSX in Depth](/react/docs/jsx-in-depth.html)
+>   * [JSX Gotchas](/react/docs/jsx-gotchas.html)
+> * [Interactivity and Dynamic UIs](/react/docs/interactivity-and-dynamic-uis.html)
+> * [Multiple Components](/react/docs/multiple-components.html)
+> * [Reusable Components](/react/docs/reusable-components.html)
+> * [Forms](/react/docs/forms.html)
+> * [Working With the Browser](/react/docs/working-with-the-browser.html)
+>   * [More About Refs](/react/docs/more-about-refs.html)
+> * [Tooling integration](/react/docs/tooling-integration.html)
+> * [Reference](/react/docs/top-level-api.html)

docs/_posts/2013-07-26-react-v0-4-1.md

@@ -0,0 +1,25 @@
+---
+title: "React v0.4.1"
+layout: post
+author: Paul O'Shannessy
+---
+
+React v0.4.1 is a small update, mostly containing correctness fixes. Some code has been restructured internally but those changes do not impact any of our public APIs.
+
+
+## React
+
+* `setState` callbacks are now executed in the scope of your component.
+* `click` events now work on Mobile Safari.
+* Prevent a potential error in event handling if `Object.prototype` is extended.
+* Don't set DOM attributes to the string `"undefined"` on update when previously defined.
+* Improved support for `<iframe>` attributes.
+* Added checksums to detect and correct cases where server-side rendering markup mismatches what React expects client-side.
+
+
+## JSXTransformer
+
+* Improved environment detection so it can be run in a non-browser environment.
+
+
+[Download it now!](/react/downloads.html)

docs/_posts/2013-07-30-use-react-and-jsx-in-ruby-on-rails.md

@@ -0,0 +1,54 @@
+---
+title: "Use React and JSX in Ruby on Rails"
+layout: post
+author: Paul O'Shannessy
+---
+
+Today we're releasing a gem to make it easier to use React and JSX in Ruby on Rails applications: [react-rails](https://github.com/facebook/react-rails).
+
+
+This gem has 2 primary purposes:
+
+1. To package `react.js` in a way that's easy to use and easy to update.
+2. To allow you to write JSX without an external build step to transform that into JS.
+
+
+## Packaging react.js
+
+To make `react.js` available for use client-side, simply add `react` to your manifest, and declare the variant you'd like to use in your environment. When you use `:production`, the minified and optimized `react.min.js` will be used instead of the development version. For example:
+
+```ruby
+# config/environments/development.rb
+
+MyApp::Application.configure do
+  config.react.variant = :development
+  # use :production in production.rb
+end
+```
+
+```js
+// app/assets/javascript/application.js
+
+//= require react
+```
+
+
+## Writing JSX
+
+When you name your file with `myfile.js.jsx`, `react-rails` will automatically try to transform that file. For the time being, we still require that you include the docblock at the beginning of the file. For example, this file will get transformed on request.
+
+```js
+/** @jsx React.DOM */
+React.renderComponent(<MyComponent/>, document.body)
+```
+
+
+## Asset Pipeline
+
+`react-rails` takes advantage of the [asset pipeline](http://guides.rubyonrails.org/asset_pipeline.html) that was introduced in Rails 3.1. A very important part of that pipeline is the `assets:precompile` Rake task. `react-rails` will ensure that your JSX files will be transformed into regular JS before all of your assets are minified and packaged.
+
+
+## Installation
+
+Installation follows the same process you're familiar with. You can install it globally with `gem install react-rails`, though we suggest you add the dependency to your `Gemfile` directly.
+

docs/_posts/2013-08-05-community-roundup-6.md

@@ -0,0 +1,80 @@
+---
+title: "Community Round-up #6"
+layout: post
+author: Vjeux
+---
+
+This is the first Community Round-up where none of the items are from Facebook/Instagram employees. It's great to see the adoption of React growing.
+
+## React Game Tutorial
+
+[Caleb Cassel](https://twitter.com/CalebCassel) wrote a [step-by-step tutorial](https://rawgithub.com/calebcassel/react-demo/master/part1.html) about making a small game. It covers JSX, State and Events, Embedded Components and Integration with Backbone.
+<figure>[![](/react/img/blog/dog-tutorial.png)](https://rawgithub.com/calebcassel/react-demo/master/part1.html)</figure>
+
+
+## Reactify
+
+[Andrey Popp](http://andreypopp.com/) created a [Browserify](http://browserify.org/) helper to compile JSX files.
+
+> Browserify v2 transform for `text/jsx`. Basic usage is:
+>
+> ```
+% browserify -t reactify main.jsx
+```
+>
+> `reactify` transform activates for files with either `.jsx` extension or `/** @jsx React.DOM */` pragma as a first line for any `.js` file.
+>
+> [Check it out on Github...](https://github.com/andreypopp/reactify)
+
+
+
+## React Integration with Este
+
+[Daniel Steigerwald](http://daniel.steigerwald.cz/) is now using React within [Este](https://github.com/steida/este), which is a development stack for web apps in CoffeeScript that are statically typed using the Closure Library.
+
+```coffeescript
+este.demos.react.todoApp = este.react.create (`/** @lends {React.ReactComponent.prototype} */`)
+  render: ->
+    @div [
+      este.demos.react.todoList 'items': @state['items']
+      if @state['items'].length
+        @p "#{@state['items'].length} items."
+      @form 'onSubmit': @onFormSubmit, [
+        @input
+          'onChange': @onChange
+          'value': @state['text']
+          'autoFocus': true
+          'ref': 'textInput'
+        @button "Add ##{@state['items'].length + 1}"
+      ]
+    ]
+```
+
+[Check it out on Github...](https://github.com/steida/este-library/blob/master/este/demos/thirdparty/react/start.coffee)
+
+
+## React Stylus Boilerplate
+
+[Zaim Bakar](http://zaim.github.io/) shared his boilerplate to get started with Stylus CSS processor.
+
+> This is my boilerplate React project using Grunt as the build tool, and Stylus as my CSS preprocessor.
+> 
+> - Very minimal HTML boilerplate
+> - Uses Stylus, with nib included
+> - Uses two build targets:
+>   - `grunt build` to compile JSX and Stylus into a development build
+>   - `grunt dist` to minify and optimize the development build for production
+>
+> [Check it out on Github...](https://github.com/zaim/react-stylus-boilerplate)
+
+
+## WebFUI
+
+[Conrad Barski](http://lisperati.com/), author of the popular book [Land of Lisp](http://landoflisp.com/), wants to use React for his ClojureScript library called [WebFUI](https://github.com/drcode/webfui).
+
+> I'm the author of "[Land of Lisp](http://landoflisp.com/)" and I love your framework. I built a somewhat similar framework a year ago [WebFUI](https://github.com/drcode/webfui) aimed at ClojureScript. My framework also uses global event delegates, a global "render" function, DOM reconciliation, etc just like react.js. (Of course these ideas all have been floating around the ether for ages, always great to see more people building on them.)
+>
+> Your implementation is more robust, and so I think the next point release of webfui will simply delegate all the "hard work" to react.js and will only focus on the areas where it adds value (enabling purely functional UI programming in clojurescript, and some other stuff related to streamlining event handling)
+<figure>[![](/react/img/blog/landoflisp.png)](https://groups.google.com/forum/#!msg/reactjs/e3bYersyd64/qODfcuBR9LwJ)</figure>
+>
+> [Read the full post...](https://groups.google.com/forum/#!msg/reactjs/e3bYersyd64/qODfcuBR9LwJ)

docs/_posts/2013-08-19-use-react-and-jsx-in-python-applications.md

@@ -0,0 +1,56 @@
+---
+title: "Use React and JSX in Python Applications"
+layout: post
+author: Kunal Mehta
+---
+
+Today we're happy to announce the initial release of [PyReact](https://github.com/facebook/react-python), which makes it easier to use React and JSX in your Python applications. It's designed to provide an API to transform your JSX files into JavaScript, as well as provide access to the latest React source files.
+
+## Usage
+
+Transform your JSX files via the provided `jsx` module:
+
+```python
+from react import jsx
+
+# For multiple paths, use the JSXTransformer class.
+transformer = jsx.JSXTransformer()
+for jsx_path, js_path in my_paths:
+    transformer.transform(jsx_path, js_path)
+
+# For a single file, you can use a shortcut method.
+jsx.transform('path/to/input/file.jsx', 'path/to/output/file.js')
+```
+
+For full paths to React files, use the `source` module:
+
+```python
+from react import source
+
+# path_for raises IOError if the file doesn't exist.
+react_js = source.path_for('react.min.js')
+```
+
+## Django
+
+PyReact includes a JSX compiler for [django-pipeline](https://github.com/cyberdelia/django-pipeline). Add it to your project's pipeline settings like this:
+
+```python
+PIPELINE_COMPILERS = (
+  'react.utils.pipeline.JSXCompiler',
+)
+```
+
+## Installation
+
+PyReact is hosted on PyPI, and can be installed with `pip`:
+
+    $ pip install PyReact
+
+Alternatively, add it into your `requirements` file:
+
+    PyReact==0.1.1
+
+**Dependencies**: PyReact uses [PyExecJS](https://github.com/doloopwhile/PyExecJS) to execute the bundled React code, which requires that a JS runtime environment is installed on your machine. We don't explicitly set a dependency on a runtime environment; Mac OS X comes bundled with one. If you're on a different platform, we recommend [PyV8](https://code.google.com/p/pyv8/).
+
+For the initial release, we've only tested on Python 2.7. Look out for support for Python 3 in the future, and if you see anything that can be improved, we welcome your [contributions](https://github.com/facebook/react-python/blob/master/CONTRIBUTING.md)!

docs/_posts/2013-08-26-community-roundup-7.md

@@ -0,0 +1,74 @@
+---
+title: "Community Round-up #7"
+layout: post
+author: Vjeux
+---
+
+It's been three months since we open sourced React and it is going well. Some stats so far:
+
+* 114 285 unique visitors on this website
+* [1933 stars](https://github.com/facebook/react/stargazers) and [210 forks](https://github.com/facebook/react/network/members)
+* [226 posts on Google Group](https://groups.google.com/forum/#!forum/reactjs)
+* [76 Github projects using React](https://gist.github.com/vjeux/6335762)
+* [30 contributors](https://github.com/facebook/react/graphs/contributors)
+* [15 blog posts](http://facebook.github.io/react/blog/)
+* 2 early adopters: [Khan Academy](http://benalpert.com/2013/06/09/using-react-to-speed-up-khan-academy.html) and [Propeller](http://usepropeller.com/blog/posts/from-backbone-to-react/)
+
+
+## Wolfenstein Rendering Engine Ported to React
+
+[Pete Hunt](http://www.petehunt.net/) ported the render code of the web version of Wolfenstein 3D to React. Check out [the demo](http://www.petehunt.net/wolfenstein3D-react/wolf3d.html) and [render.js](https://github.com/petehunt/wolfenstein3D-react/blob/master/js/renderer.js#L183) file for the implementation.
+<figure>[![](/react/img/blog/wolfenstein_react.png)](http://www.petehunt.net/wolfenstein3D-react/wolf3d.html)</figure>
+
+
+## React & Meteor
+
+[Ben Newman](https://twitter.com/benjamn) made a [13-lines wrapper](https://github.com/benjamn/meteor-react/blob/master/lib/mixin.js) to use React and Meteor together. [Meteor](http://www.meteor.com/) handles the real-time data synchronization between client and server. React provides the declarative way to write the interface and only updates the parts of the UI that changed.
+
+> This repository defines a Meteor package that automatically integrates the React rendering framework on both the client and the server, to complement or replace the default Handlebars templating system.
+>
+> The React core is officially agnostic about how you fetch and update your data, so it is far from obvious which approach is the best. This package provides one answer to that question (use Meteor!), and I hope you will find it a compelling combination.
+>
+>```javascript
+>var MyComponent = React.createClass({
+>  mixins: [MeteorMixin],
+>
+>  getMeteorState: function() {
+>    return { foo: Session.get('foo') };
+>  },
+>
+>  render: function() {
+>    return <div>{this.state.foo}</div>;
+>  }
+>});
+>```
+>
+> Dependencies will be registered for any data accesses performed by getMeteorState so that the component can be automatically re-rendered whenever the data changes.
+>
+> [Read more ...](https://github.com/benjamn/meteor-react)
+
+## React Page
+
+[Jordan Walke](https://github.com/jordwalke) implemented a complete React project creator called [react-page](https://github.com/facebook/react-page/). It supports both server-side and client-side rendering, source transform and packaging JSX files using CommonJS modules, and instant reload.
+
+> Easy Application Development with React JavaScript
+> <figure>[![](/react/img/blog/react-page.png)](https://github.com/facebook/react-page/)</figure>
+>
+> **Why Server Rendering?**
+>
+> * Faster initial page speed:
+>   * Markup displayed before downloading large JavaScript.
+>   * Markup can be generated more quickly on a fast server than low power client devices.
+> * Faster Development and Prototyping:
+>   * Instantly refresh your app without waiting for any watch scripts or bundlers.
+> * Easy deployment of static content pages/blogs: just archive using recursive wget.
+> * SEO benefits of indexability and perf.
+>
+> **How Does Server Rendering Work?**
+>
+> * `react-page` computes page markup on the server, sends it to the client so the user can see it quickly.
+> * The corresponding JavaScript is then packaged and sent.
+> * The browser runs that JavaScript, so that all of the event handlers, interactions and update code will run seamlessly on top of the server generated markup.
+> * From the developer's (and the user's) perspective, it's just as if the rendering occurred on the client, only faster.
+>
+> [Try it out ...](https://github.com/facebook/react-page/)

docs/_posts/2013-09-24-community-roundup-8.md

@@ -0,0 +1,70 @@
+---
+title: "Community Round-up #8"
+layout: post
+author: Vjeux
+---
+
+A lot has happened in the month since our last update. Here are some of the more interesting things we've found. But first, we have a couple updates before we share links.
+
+First, we are organizing a [React Hackathon](http://reactjshack-a-thon.splashthat.com/) in Facebook's Seattle office on Saturday September 28. If you want to hack on React, meet some of the team or win some prizes, feel free to join us!
+
+We've also reached a point where there are too many questions for us to handle directly. We're encouraging people to ask questions on [StackOverflow](http://stackoverflow.com/questions/tagged/reactjs) using the tag [[reactjs]](http://stackoverflow.com/questions/tagged/reactjs). Many members of the team and community have subscribed to the tag, so feel free to ask questions there. We think these will be more discoverable than Google Groups archives or IRC logs.
+
+## Javascript Jabber
+
+[Pete Hunt](http://www.petehunt.net/) and [Jordan Walke](https://github.com/jordwalke) were interviewed on [Javascript Jabber](http://javascriptjabber.com/073-jsj-react-with-pete-hunt-and-jordan-walke/) for an hour.  They go over many aspects of React such as 60 FPS, Data binding, Performance, Diffing Algorithm, DOM Manipulation, Node.js support, server-side rendering, JSX, requestAnimationFrame and the community. This is a gold mine of information about React.
+
+> **PETE:**  So React was designed all around that. Conceptually, how you build a React app is that every time your data changes, it's like hitting the refresh button in a server-rendered app. What we do is we conceptually throw out all of the markup and event handlers that you've registered and we reset the whole page and then we redraw the entire page. If you're writing a server-rendered app, handling updates is really easy because you hit the refresh button and you're pretty much guaranteed to get what you expect.
+>
+> **MERRICK:**  That's true. You don't get into these odd states.
+>
+> **PETE:**  Exactly, exactly. In order to implement that, we communicate it as a fake DOM. What we'll do is rather than throw out the actual browser html and event handlers, we have an internal representation of what the page looks like and then we generate a brand new representation of what we want the page to look like. Then we perform this really, really fast diffing algorithm between those two page representations, DOM representations. Then React will compute the minimum set of DOM mutations it needs to make to bring the page up to date.
+>
+> Then to finally get to answer your question, that set of DOM mutations then goes into a queue and we can plug in arbitrary flushing strategies for that. For example, when we originally launched React in open source, every setState would immediately trigger a flush to the DOM. That wasn't part of the contract of setState, but that was just our strategy and it worked pretty well. Then this totally awesome open source contributor Ben Alpert at Khan Academy built a new batching strategy which would basically queue up every single DOM update and state change that happened within an event tick and would execute them in bulk at the end of the event tick.
+>
+> [Read the full conversation ...](http://javascriptjabber.com/073-jsj-react-with-pete-hunt-and-jordan-walke/)
+
+
+## JSXTransformer Trick
+
+While this is not going to work for all the attributes since they are camelCased in React, this is a pretty cool trick.
+
+<div style="margin-left: 74px;"><blockquote class="twitter-tweet"><p>Turn any DOM element into a React.js function: JSXTransformer.transform(&quot;/** <a href="https://twitter.com/jsx">@jsx</a> React.DOM */&quot; + element.innerHTML).code</p>&mdash; Ross Allen (@ssorallen) <a href="https://twitter.com/ssorallen/statuses/377105575441489920">September 9, 2013</a></blockquote></div>
+<script async src="//platform.twitter.com/widgets.js" charset="utf-8"></script>
+
+
+## Remarkable React
+
+[Stoyan Stefanov](http://www.phpied.com/) gave a talk at [BrazilJS](http://braziljs.com.br/) about React and wrote an article with the content of the presentation. He goes through the difficulties of writting _active apps_ using the DOM API and shows how React handles it.
+
+> So how does exactly React deal with it internally? Two crazy ideas - virtual DOM and synthetic events.
+>
+> You define you components in React. It builds a virtual DOM in JavaScript land which is way more efficient. Then it updates the DOM. (And "virtual DOM" is a very big name for what is simply a JavaScript object with nested key-value pairs)
+>
+> Data changes. React computes a diff (in JavaScript land, which is, of course, much more efficient) and updates the single table cell that needs to change. React replicates the state of the virtual DOM into the actual DOM only when and where it's necessary. And does it all at once, in most cases in a single tick of the `requestAnimationFrame()`.
+>
+> What about event handlers? They are synthetic. React uses event delegation to listen way at the top of the React tree. So removing a node in the virtual DOM has no effect on the event handling.
+>
+> The events are automatically cross-browser (they are React events). They are also much closer to W3C than any browser. That means that for example `e.target` works, no need to look for the event object or checking whether it's `e.target` or `e.srcElement` (IE). Bubbling and capturing phases also work cross browser. React also takes the liberty of making some small fixes, e.g. the event `<input onChange>` fires when you type, not when blur away from the input. And of course, event delegation is used as the most efficient way to handle events. You know that "thou shall use event delegation" is also commonly given advice for making web apps snappy.
+>
+> The good thing about the virtual DOM is that it's all in JavaScript land. You build all your UI in JavaScript. Which means it can be rendered on the server side, so you initial view is fast (and any SEO concerns are addressed). Also, if there are especially heavy operations they can be threaded into WebWorkers, which otherwise have no DOM access.
+>
+> [Read More ...](http://www.phpied.com/remarkable-react/)
+
+
+## Markdown in React
+
+[Ben Alpert](http://benalpert.com/) converted [marked](https://github.com/chjj/marked), a Markdown Javascript implementation, in React: [marked-react](https://github.com/spicyj/marked-react). Even without using JSX, the HTML generation is now a lot cleaner. It is also safer as forgetting a call to `escape` will not introduce an XSS vulnerability.
+<figure>[![](/react/img/blog/markdown_refactor.png)](https://github.com/spicyj/marked-react/commit/cb70c9df6542c7c34ede9efe16f9b6580692a457)</figure>
+
+
+## Unite from BugBusters
+
+[Renault John Lecoultre](https://twitter.com/renajohn) wrote [Unite](https://www.bugbuster.com/), an interactive tool for analyzing code dynamically using React. It integrates with CodeMirror.
+<figure>[![](/react/img/blog/unite.png)](https://unite.bugbuster.com/)</figure>
+
+## #reactjs IRC Logs
+
+[Vjeux](http://blog.vjeux.com/) re-implemented the display part of the IRC logger in React. Just 130 lines are needed for a performant infinite scroll with timestamps and color-coded author names.
+
+<iframe width="100%" height="300" src="http://jsfiddle.net/vjeux/QL9tz/embedded/" allowfullscreen="allowfullscreen" frameborder="0"></iframe>

docs/_posts/2013-10-3-community-roundup-9.md

@@ -0,0 +1,100 @@
+---
+title: "Community Round-up #9"
+layout: post
+author: Vjeux
+---
+
+We organized a React hackathon last week-end in the Facebook Seattle office. 50 people, grouped into 15 teams, came to hack for a day on React. It was a lot of fun and we'll probably organize more in the future.
+
+![](/react/img/blog/react-hackathon.jpg)
+
+
+## React Hackathon Winner
+
+[Alex Swan](http://bold-it.com/) implemented [Qu.izti.me](http://qu.izti.me/), a multi-player quiz game. It is real-time via Web Socket and mobile friendly.
+
+> The game itself is pretty simple. People join the "room" by going to [http://qu.izti.me](http://qu.izti.me/) on their device. Large displays will show a leaderboard along with the game, and small displays (such as phones) will act as personal gamepads. Users will see questions and a choice of answers. The faster you answer, the more points you earn.
+>
+> In my opinion, Socket.io and React go together like chocolate and peanut butter. The page was always an accurate representation of the game object.
+><figure>[![](/react/img/blog/quiztime.png)](http://bold-it.com/javascript/facebook-react-example/)</figure>
+>
+> [Read More...](http://bold-it.com/javascript/facebook-react-example/)
+
+## JSConf EU Talk: Rethinking Best Practices
+
+[Pete Hunt](http://www.petehunt.net/) presented React at JSConf EU. He covers three controversial design decisions of React:
+
+1. Build **components**, not templates
+2. Re-render the whole app on every update
+3. Virtual DOM
+
+The video will be available soon on the [JSConf EU website](http://2013.jsconf.eu/speakers/pete-hunt-react-rethinking-best-practices.html), but in the meantime, here are Pete's slides:
+
+<figure><iframe src="http://www.slideshare.net/slideshow/embed_code/26589373" width="550" height="450" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen></iframe></figure>
+
+
+## Pump - Clojure bindings for React
+
+[Alexander Solovyov](http://solovyov.net/) has been working on React bindings for ClojureScript. This is really exciting as it is using "native" ClojureScript data structures.
+
+```ruby
+(ns your.app
+  (:require-macros [pump.def-macros :refer [defr]])
+  (:require [pump.core]))
+
+(defr Component
+  :get-initial-state #(identity {:some-value ""})
+
+  [component props state]
+
+  [:div {:class-name "test"} "hello"])
+```
+
+[Check it out on GitHub...](https://github.com/piranha/pump)
+
+
+## JSXHint
+
+[Todd Kennedy](http://blog.selfassembled.org/) working at [Cond&eacute; Nast](http://www.condenast.com/) implemented a wrapper on-top of [JSHint](http://www.jshint.com/) that first converts JSX files to JS.
+
+> A wrapper around JSHint to allow linting of files containg JSX syntax. Accepts glob patterns. Respects your local .jshintrc file and .gitignore to filter your glob patterns.
+>
+> ```
+npm install -g jsxhint
+```
+>
+> [Check it out on GitHub...](https://github.com/CondeNast/JSXHint)
+
+
+## Turbo React
+
+[Ross Allen](https://twitter.com/ssorallen) working at [Mesosphere](http://mesosphere.io/) combined [Turbolinks](https://github.com/rails/turbolinks/), a library used by Ruby on Rails to speed up page transition, and React.
+
+> "Re-request this page" is just a link to the current page. When you click it, Turbolinks intercepts the GET request and fetchs the full page via XHR.
+>
+> The panel is rendered with a random panel- class on each request, and the progress bar gets a random widthX class.
+>
+> With Turbolinks alone, the entire <body> would be replaced, and transitions would not happen. In this little demo though, React adds and removes classes and text, and the attribute changes are animated with CSS transitions. The DOM is otherwise left intact.
+><figure>[![](/react/img/blog/turboreact.png)](https://turbo-react.herokuapp.com/)</figure>
+>
+> [Check out the demo...](https://turbo-react.herokuapp.com/)
+
+
+## Reactive Table
+
+[Stoyan Stefanov](http://www.phpied.com/) continues his series of blog posts about React. This one is an introduction tutorial on rendering a simple table with React.
+
+> React is all about components. So let's build one.
+>
+> Let's call it Table (to avoid any confusion what the component is about).
+>
+> ```javascript
+var Table = React.createClass({
+  /*stuff goeth here*/
+});
+```
+>
+> You see that React components are defined using a regular JS object. Some properties and methods of the object such as render() have special meanings, the rest is upforgrabs.
+>
+> [Read the full article...](http://www.phpied.com/reactive-table/)
+

docs/blog/all.html

@@ -0,0 +1,15 @@
+---
+title: Blog
+layout: default
+sectionid: blog
+id: all-posts
+---
+
+<section class="content wrap documentationContent nosidebar">
+  <div class="inner-content">
+    <h1>All Posts</h1>
+    {% for page in site.posts %}
+      <p><strong><a href="/react{{ page.url }}">{{ page.title }}</a></strong> on {{ page.date | date: "%B %e, %Y" }} by {{ page.author }}</p>
+    {% endfor %}
+  </div>
+</section>

docs/blog/index.html

@@ -7,22 +7,28 @@ sectionid: blog
 <section class="content wrap blogContent">
   {% include nav_blog.html %}
   <div class="inner-content">
-    {% for page in site.posts %}
+    {% for page in paginator.posts %}
       <div class="post-list-item">
         <h1><a href="/react{{ page.url }}">{{ page.title }}</a></h1>
         <p class="meta">{{ page.date | date: "%B %e, %Y" }} by {{ page.author }}</p>
-
-        <hr>
-
+        <hr />
         <div class="post">
-         {{ page.excerpt }}
-         {% if page.excerpt != page.content %}
-           <p>
-             <a href="/react{{ page.url }}">Continue Reading &rarr;</a>
-          </p>
-         {% endif %}
+         {{ page.content }}
         </div>
       </div>
     {% endfor %}
+
+    <div class="pagination">
+      {% if paginator.previous_page %}
+        <a href="/react/blog/{{ paginator.previous_page_path }}" class="previous">
+          &laquo; Previous Page
+        </a>
+      {% endif %}
+      {% if paginator.next_page %}
+        <a href="/react/blog/{{ paginator.next_page_path }}" class="next">
+          Next Page &raquo;
+        </a>
+      {% endif %}
+    </div>
   </div>
 </section>

docs/docs/02.1-jsx-in-depth.md

@@ -82,7 +82,7 @@ var div = React.DOM.div;
 var app = <div className="appClass">Hello, React!</div>;
 ```
 
-### React Component Components
+### React Composite Components
 
 To construct an instance of a composite component, create a variable that
 references the class.
@@ -92,7 +92,7 @@ var MyComponent = React.createClass({/*...*/});
 var app = <MyComponent someProperty={true} />;
 ```
 
-See [Component Basics](component-basics.html) to learn more about components.
+See [Multiple Components](multiple-components.html) to learn more about using composite components.
 
 > Note:
 >
@@ -162,10 +162,15 @@ var content = <Container>{/* this is a comment */}<Nav /></Container>;
 Beyond the compilation step, JSX does not require any special tools.
 
 * Many editors already include reasonable support for JSX (Vim, Emacs js2-mode).
+  * JSX syntax highlighting is available for Sublime Text and other editors
+    that support `*.tmLanguage` using the third-party
+    [`JavaScript (JSX).tmLanguage`][1].
 * Linting provides accurate line numbers after compiling without sourcemaps.
 * Elements use standard scoping so linters can find usage of out-of-scope
   components.
 
+[1]: https://github.com/yungsters/sublime/blob/master/tmLanguage/JavaScript%20(JSX).tmLanguage
+
 ## Prior Work
 
 JSX is similar to several other JavaScript embedded XML language

docs/docs/04-multiple-components.md

@@ -62,7 +62,7 @@ React.renderComponent(
 
 In the above example, instances of `Avatar` *own* instances of `ProfilePic` and `ProfileLink`. In React, **an owner is the component that sets the `props` of other components**. More formally, if a component `X` is created in component `Y`'s `render()` method, it is said that `X` is *owned by* `Y`. As discussed earlier, a component cannot mutate its `props` — they are always consistent with what its owner sets them to. This key property leads to UIs that are guaranteed to be consistent.
 
-It's important to draw a distinciton between the owner-ownee relationship and the parent-child relationship. The owner-ownee relationship is specific to React, while the parent-child relationship is simply the one you know and love from the DOM. In the example above, `Avatar` owns the `div`, `ProfilePic` and `ProfileLink` instances, and `div` is the **parent** (but not owner) of the `ProfilePic` and `ProfileLink` instances.
+It's important to draw a distinction between the owner-ownee relationship and the parent-child relationship. The owner-ownee relationship is specific to React, while the parent-child relationship is simply the one you know and love from the DOM. In the example above, `Avatar` owns the `div`, `ProfilePic` and `ProfileLink` instances, and `div` is the **parent** (but not owner) of the `ProfilePic` and `ProfileLink` instances.
 
 
 ## Children
@@ -144,7 +144,7 @@ In React, data flows from owner to owned component through `props` as discussed
 
 You may be thinking that it's expensive to react to changing data if there are a large number of nodes under an owner. The good news is that JavaScript is fast and `render()` methods tend to be quite simple, so in most applications this is extremely fast. Additionally, the bottleneck is almost always the DOM mutation and not JS execution and React will optimize this for you using batching and change detection.
 
-However, sometimes you really want to have fine-grained control over your performance. In that case, simply override `shouldComponentUpdate()` to return false when you want React to skip processing of a subtree. See [the React reference docs](./reference.html) for more information.
+However, sometimes you really want to have fine-grained control over your performance. In that case, simply override `shouldComponentUpdate()` to return false when you want React to skip processing of a subtree. See [the React reference docs](component-specs.html) for more information.
 
 > Note:
 >

docs/docs/05-reusable-components.md

@@ -35,7 +35,7 @@ React.createClass({
     someClass: React.PropTypes.instanceOf(SomeClass),
 
     // You can chain any of the above with isRequired to make sure an error is
-    // thrown if the prop isn't provide.
+    // thrown if the prop isn't provided.
     requiredFunc: React.PropTypes.func.isRequired
 
     // You can also specify a custom validator.
@@ -77,7 +77,7 @@ A common type of React component is one that extends a basic HTML in a simple wa
 
 var CheckLink = React.createClass({
   render: function() {
-    // transferPropsTo() will take any props pased to CheckLink
+    // transferPropsTo() will take any props passed to CheckLink
     // and copy them to <a>
     return this.transferPropsTo(<a>{'√ '}{this.props.children}</a>);
   }

docs/docs/07-working-with-the-browser.md

@@ -110,23 +110,25 @@ _Mounted_ composite components also support the following methods:
 > calling `this.getDOMNode()`.
 
 
-## Browser Suppport and Polyfills
+## Browser Support and Polyfills
 
 At Facebook, we support older browsers, including IE8. We've had polyfills in place for a long time to allow us to write forward-thinking JS. This means we don't have a bunch of hacks scattered throughout our codebase and we can still expect our code to "just work". For example, instead of seeing `+new Date()`, we can just write `Date.now()`. Since the open source React is the same as what we use internally, we've carried over this philosophy of using forward thinking JS.
 
-In addition to that philosphy, we've also taken the stance that we, as authors of a JS library, should not be shipping polyfills as a part of our library. If every library did this, there's a good chance you'd be sending down the same polyfill multiple times, which could be a sizable chunk of dead code. If your product needs to support older browsers, chances are you're already using something like [es5-shim](https://github.com/kriskowal/es5-shim).
+In addition to that philosophy, we've also taken the stance that we, as authors of a JS library, should not be shipping polyfills as a part of our library. If every library did this, there's a good chance you'd be sending down the same polyfill multiple times, which could be a sizable chunk of dead code. If your product needs to support older browsers, chances are you're already using something like [es5-shim](https://github.com/kriskowal/es5-shim).
 
 
 ### Polyfills Needed to Support Older Browsers
 
+These six functions can be polyfilled using `es5-shim.js` from [kriskowal's es5-shim](https://github.com/kriskowal/es5-shim):
+
 * `Array.isArray`
 * `Array.prototype.forEach`
 * `Array.prototype.indexOf`
-* `Function.prototype.bind`
+* `Array.prototype.some`
 * `Date.now`
-* `Array.prototype.some` (also in `es5-shim.js`)
+* `Function.prototype.bind`
 
-All of these can be polyfilled using `es5-shim.js` from [https://github.com/kriskowal/es5-shim](https://github.com/kriskowal/es5-shim).
+Other required polyfills:
 
-* `console.*` - Only needed when not using the minified build. If you need to polyfill this, try [https://github.com/paulmillr/console-polyfill](https://github.com/paulmillr/console-polyfill).
-* `Object.create` - Provided in `es5-sham.js` @ [https://github.com/kriskowal/es5-shim](https://github.com/kriskowal/es5-shim).
+* `Object.create` – Provided by `es5-sham.js` from [kriskowal's es5-shim](https://github.com/kriskowal/es5-shim).
+* `console.*` – Only needed when using the unminified build. If you need to polyfill this, try [paulmillr's console-polyfill](https://github.com/paulmillr/console-polyfill).

docs/docs/07.1-more-about-refs.md

@@ -39,7 +39,7 @@ Consider the case when you wish to tell an `<input />` element (that exists with
 ```
 
 
-Notice how, in this example, we want to "tell" the input something - something that it cannot infer from it's props over time. In this case we want to "tell" it that it should now become focused. However, there are some challenges. What is returned from `render()`` is not your actual composition of "child" components, it is merely a *description* of the children at a particular instance in time - a snapshot, if you will.
+Notice how, in this example, we want to "tell" the input something - something that it cannot infer from its props over time. In this case we want to "tell" it that it should now become focused. However, there are some challenges. What is returned from `render()` is not your actual composition of "child" components, it is merely a *description* of the children at a particular instance in time - a snapshot, if you will.
 
 > Note:
 >
@@ -115,7 +115,7 @@ It's as simple as:
   });
 ```
 
-In this example, our render function returns a description of an `<input />` instance. But the true instance is accessed via `this.refs.theInput`. As long as a child component with `ref="theInput"` is returned from render, `this.refs.theInput` will access the the proper instance. This even works on higher level (non-DOM) components such as `<Typeahead ref="myTypeahead" />`.
+In this example, our render function returns a description of an `<input />` instance. But the true instance is accessed via `this.refs.theInput`. As long as a child component with `ref="theInput"` is returned from render, `this.refs.theInput` will access the proper instance. This even works on higher level (non-DOM) components such as `<Typeahead ref="myTypeahead" />`.
 
 
 ## Summary

docs/docs/08-tooling-integration.md

@@ -1,26 +1,28 @@
 ---
 id: tooling-integration
-title: Tooling integration
+title: Tooling Integration
 layout: docs
 permalink: tooling-integration.html
 prev: more-about-refs.html
-next: reference.html
+next: examples.html
 ---
 
 Every project uses a different system for building and deploying JavaScript. We've tried to make React as environment-agnostic as possible.
 
+## React
 
-## CDN-hosted React
+### CDN-hosted React
 
 We provide CDN-hosted versions of React [on our download page](/react/downloads.html). These prebuilt files use the UMD module format. Dropping them in with a simple `<script>` tag will inject a `React` global into your environment. It should also work out-of-the-box in CommonJS and AMD environments.
 
 
-## Using master
+### Using master
 
 We have instructions for building from `master` [in our GitHub repository](https://github.com/facebook/react). We build a tree of CommonJS modules under `build/modules` which you can drop into any environment or packaging tool that supports CommonJS.
 
+## JSX
 
-## In-browser JSX Transform
+### In-browser JSX Transform
 
 If you like using JSX, we provide an in-browser JSX transformer for development [on our download page](/react/downloads.html). Simply include a `<script type="text/jsx">` tag to engage the JSX transformer. Be sure to include the `/** @jsx React.DOM */` comment as well, otherwise the transformer will not run the transforms.
 
@@ -29,16 +31,22 @@ If you like using JSX, we provide an in-browser JSX transformer for development
 > The in-browser JSX transformer is fairly large and results in extraneous computation client-side that can be avoided. Do not use it in production — see the next section.
 
 
-## Productionizing: Precompiled JSX
+### Productionizing: Precompiled JSX
 
 If you have [npm](http://npmjs.org/), you can simply run `npm install -g react-tools` to install our command-line `jsx` tool. This tool will translate files that use JSX syntax to plain JavaScript files that can run directly in the browser. It will also watch directories for you and automatically transform files when they are changed; for example: `jsx --watch src/ build/`. Run `jsx --help` for more information on how to use this tool.
 
 
-## Helpful Open-Source Projects
+### Helpful Open-Source Projects
 
 The open-source community has built tools that integrate JSX with several build systems.
 
-* [reactify](https://github.com/andreypopp/reactify) - use JSX with [browserify](http://browserify.org/).
+* [reactify](https://github.com/andreypopp/reactify) - use JSX with [browserify](http://browserify.org/)
 * [grunt-react](https://github.com/ericclemmons/grunt-react) - [grunt](http://gruntjs.com/) task for JSX
 * [require-jsx](https://github.com/seiffert/require-jsx) - use JSX with [require.js](http://requirejs.org/)
-* [reactapp](https://github.com/jordwalke/reactapp) - a sample project to get up-and-running with React quickly
+* [pyReact](https://github.com/facebook/react-python) - use JSX with [Python](http://www.python.org/)
+* [react-rails](https://github.com/facebook/react-rails) - use JSX with [Ruby on Rails](http://rubyonrails.org/)
+
+
+## React Page
+
+To get started on a new project, you can use [react-page](https://github.com/facebook/react-page/), a complete React project creator. It supports both server-side and client-side rendering, source transform and packaging JSX files using CommonJS modules, and instant reload.

docs/docs/09-examples.md

@@ -0,0 +1,22 @@
+---
+id: examples
+title: Examples
+layout: docs
+permalink: examples.html
+prev: tooling-integration.html
+---
+
+### Production Apps
+
+* All of [Instagram.com](http://instagram.com/) is built on React.
+* Many components on [Facebook.com](http://www.facebook.com/), including the commenting interface, ads creation flows, and page insights.
+* [Khan Academy](http://khanacademy.org/) is using React for its question editor.
+
+
+### Sample Code
+
+* We've included [a step-by-step comment box tutorial](./tutorial.html).
+* [The React starter kit](/react/downloads.html) includes several examples which you can [view online in our GitHub repository](https://github.com/facebook/react/tree/master/examples/).
+* [React Page](https://github.com/facebook/react-page) is a simple React project creator to get you up-and-running quickly with React. It supports both server-side and client-side rendering, source transform and packaging JSX files using CommonJS modules, and instant reload.
+* [React one-hour email](https://github.com/petehunt/react-one-hour-email/commits/master) goes step-by-step from a static HTML mock to an interactive email reader (written in just one hour!)
+* [Rendr + React app template](https://github.com/petehunt/rendr-react-template/) demonstrates how to use React's server rendering capabilities.

docs/docs/09-reference.md

@@ -1,209 +0,0 @@
----
-id: reference
-title: Reference
-layout: docs
-permalink: reference.html
-prev: tooling-integration.html
----
-
-## Examples
-
-
-### Production Apps
-
-* All of [Instagram.com](http://instagram.com/) is built on React.
-* Many components on [Facebook.com](http://www.facebook.com/), including the commenting interface, ads creation flows, and page insights.
-* [Khan Academy](http://khanacademy.org/) is using React for its question editor.
-
-
-### Sample Code
-
-* We've included [a step-by-step comment box tutorial](./tutorial.html).
-* [The React starter kit](/react/downloads.html) includes several examples which you can [view online in our GitHub repository](https://github.com/facebook/react/tree/master/examples/).
-* [reactapp](https://github.com/jordwalke/reactapp) is a simple app template to get you up-and-running quickly with React.
-* [React one-hour email](https://github.com/petehunt/react-one-hour-email/commits/master) goes step-by-step from a static HTML mock to an interactive email reader (written in just one hour!)
-* [Rendr + React app template](https://github.com/petehunt/rendr-react-template/) demonstrates how to use React's server rendering capabilities.
-
-
-## API
-
-### React
-
-`React` is the entry point to the React framework. If you're using one of the prebuilt packages it's available as a global; if you're using CommonJS modules you can `require()` it.
-
-
-#### React.DOM
-
-`React.DOM` provides all of the standard HTML tags needed to build a React app. You generally don't use it directly; instead, just include it as part of the `/** @jsx React.DOM */` docblock.
-
-
-#### React.initializeTouchEvents
-
-```javascript
-initializeTouchEvents(boolean shouldUseTouch)
-```
-
-Configure React's event system to handle touch events on mobile devices.
-
-
-#### React.createClass
-
-```javascript
-function createClass(object specification)
-```
-
-Creates a component given a specification. A component implements a `render` method which returns **one single** child. That child may have an arbitrarily deep child structure. One thing that makes components different than a standard prototypal classes is that you don't need to call new on them. They are convenience wrappers that construct backing instances (via new) for you.
-
-
-#### React.renderComponent
-
-```javascript
-ReactComponent renderComponent(ReactComponent container, DOMElement container)
-```
-
-Renders a React component into the DOM in the supplied `container`.
-
-If the React component was previously rendered into `container`, this will perform an update on it and only mutate the DOM as necessary to reflect the latest React component.
-
-
-#### React.unmountAndReleaseReactRootNode
-
-```javascript
-unmountAndReleaseReactRootNode(DOMElement container)
-```
-
-Remove a mounted React component from the DOM and clean up its event handlers and state.
-
-
-#### React.renderComponentToString
-
-```javascript
-renderComponentToString(ReactComponent component, function callback)
-```
-
-Render a component to its initial HTML. This should only be used on the server. React will call `callback` with an HTML string when the markup is ready. You can use this method to create static site generators, or you can generate HTML on the server and send it down to have a very fast initial page load. If you call `React.renderComponent()` on a node that already has this server-rendered markup, React will preserve it and only attach event handlers, allowing you to have a very performant first-load experience.
-
-
-### AbstractEvent
-
-Your event handlers will be passed instances of `AbstractEvent`, a cross-browser wrapper around the browser's native event. It has the same interface as the browser's native event (such as `stopPropagation()` and `preventDefault()`) except they work exactly the same across all browsers.
-
-If you find that you need the underlying browser event for some reason, simply use the `nativeEvent` attribute to get it.
-
-
-### ReactComponent
-
-Component classses created by `createClass()` return instances of `ReactComponent` when called. Most of the time when you're using React you're either creating or consuming `ReactComponent`s.
-
-
-#### getDOMNode
-
-```javascript
-DOMElement getDOMNode()
-```
-
-If this component has been mounted into the DOM, this returns the corresponding native browser DOM element. This method is useful for reading values out of the DOM, such as form field values and performing DOM measurements.
-
-
-#### setProps
-
-```javascript
-setProps(object nextProps)
-```
-
-When you're integrating with an external JavaScript application you may want to signal a change to a React component rendered with `renderComponent()`. Simply call `setProps()` to change its properties and trigger a re-render.
-
-> Note:
->
-> This method can only be called on a root-level component. That is, it's only available on the component passed directly to `renderComponent()` and none of its children. If you're inclined to use `setProps()` on a child component, instead take advantage of reactive updates and pass the new prop to the child component when it's created in `render()`.
-
-
-#### replaceProps
-
-```javascript
-replaceProps(object nextProps)
-```
-
-Like `setProps()` but deletes any pre-existing props that are not in nextProps.
-
-
-#### transferPropsTo
-
-```javascript
-ReactComponent transferPropsTo(ReactComponent targetComponent)
-```
-
-Transfer properties from this component to a target component that have not already been set on the target component. This is usually used to pass down properties to the returned root component. `targetComponent`, now updated with some new props is returned as a convenience.
-
-
-#### setState
-
-```javascript
-setState(object nextState[, function callback])
-```
-
-Merges nextState with the current state. This is the primary method you use to trigger UI updates from event handlers and server request callbacks.  In addition, you can supply an optional callback function that is executed once `setState` is completed.
-
-> Note:
->
-> *NEVER* mutate `this.state` directly. As calling `setState()` afterwards may replace the mutation you made. Treat `this.state` as if it were immutable.
-
-> Note:
->
-> `setState()` does not immediately mutate `this.state` but creates a pending state transition. Accessing `this.state` after calling this method can potentially return the existing value.
-
-> Note:
->
-> There is no guarantee of synchronous operation of calls to `setState` and calls may be batched for performance gains.
-
-
-#### replaceState
-
-```javascript
-replaceState(object nextState[, function callback])
-```
-
-Like `setState()` but deletes any pre-existing state keys that are not in nextState.
-
-
-#### forceUpdate()
-
-```javascript
-forceUpdate([function callback])
-```
-
-If your `render()` method reads from something other than `this.props` or `this.state` you'll need to tell React when it needs to re-run `render()`. Use `forceUpdate()` to cause React to automatically re-render. This will cause `render()` to be called on the component and all of its children but React will only update the DOM if the markup changes.
-
-Normally you should try to avoid all uses of `forceUpdate()` and only read from `this.props` and `this.state` in `render()`. This makes your application much simpler and more efficient.
-
-> Note:
->
-> There is no guarantee of synchronous operation of calls to `forceUpdate` and calls may be batched for performance gains.
-
-
-#### Lifecycle methods
-
-```javascript
-object getInitialState()
-componentWillMount()
-componentDidMount(DOMElement domNode)
-componentWillReceiveProps(object nextProps)
-boolean shouldComponentUpdate(object nextProps, object nextState)
-componentWillUpdate(object nextProps, object nextState)
-ReactComponent render()
-componentDidUpdate(object prevProps, object prevState, DOMElement domNode)
-componentWillUnmount()
-```
-
-See the [working with the browser](./working-with-the-browser.html) documentation for more details on these lifecycle methods.
-
-
-## DOM Differences
-
-React has implemented a browser-independent events and DOM system for performance and cross-browser compatibility reasons. We took the opportunity to clean up a few rough edges in browser DOM implementations.
-
-* All events (including submit) bubble correctly per the W3C spec
-* All event objects conform to the W3C spec
-* All DOM properties and attributes (including event handlers) should be camelCased to be consistent with standard JavaScript style. We intentionally break with the spec here, since the spec is inconsistent.
-* The `style` attribute accepts a JavaScript object with camelCased properties rather than a CSS string. This is consistent with the DOM `style` JavaScript property, is more efficient, and prevents XSS security holes.
-* `onChange` behaves as you would expect it to: whenever a form field is changed this event is fired rather than inconsistently on blur. We intentionally break from existing browser behavior because `onChange` is a misnomer for its behavior and React relies on this event to react to user input in real time.

docs/docs/getting-started.md

@@ -44,7 +44,7 @@ In the root directory of the starter kit, create a `helloworld.html` with the fo
 </html>
 ```
 
-The XML syntax inside of JavaScript is called JSX; check out the [JSX syntax](syntax.html) to learn more about it. In order to translate it to vanilla JavaScript we use `<script type="text/jsx">` and include `JSXTransformer.js` to actually perform the transformation in the browser.
+The XML syntax inside of JavaScript is called JSX; check out the [JSX syntax](jsx-in-depth.html) to learn more about it. In order to translate it to vanilla JavaScript we use `<script type="text/jsx">` and include `JSXTransformer.js` to actually perform the transformation in the browser.
 
 ### Separate File
 
@@ -84,7 +84,7 @@ The file `build/helloworld.js` is autogenerated whenever you make a change.
 /** @jsx React.DOM */
 React.renderComponent(
   React.DOM.h1(null, 'Hello, world!'),
-  document.getElementyById('example')
+  document.getElementById('example')
 );
 ```
 

docs/docs/index.html

@@ -0,0 +1,4 @@
+---
+layout: redirect
+destination: getting-started.html
+---

docs/docs/ref-01-top-level-api.md

@@ -0,0 +1,73 @@
+---
+id: top-level-api
+title: Top-Level API
+layout: docs
+permalink: top-level-api.html
+next: component-api.html
+---
+
+## React
+
+`React` is the entry point to the React framework. If you're using one of the prebuilt packages it's available as a global; if you're using CommonJS modules you can `require()` it.
+
+
+### React.DOM
+
+`React.DOM` provides all of the standard HTML tags needed to build a React app. You generally don't use it directly; instead, just include it as part of the `/** @jsx React.DOM */` docblock.
+
+
+### React.initializeTouchEvents
+
+```javascript
+initializeTouchEvents(boolean shouldUseTouch)
+```
+
+Configure React's event system to handle touch events on mobile devices.
+
+
+### React.createClass
+
+```javascript
+function createClass(object specification)
+```
+
+Creates a component given a specification. A component implements a `render` method which returns **one single** child. That child may have an arbitrarily deep child structure. One thing that makes components different than standard prototypal classes is that you don't need to call new on them. They are convenience wrappers that construct backing instances (via new) for you.
+
+For more information about the specification object, see [Component Specs and Lifecycle](component-specs.html).
+
+
+### React.renderComponent
+
+```javascript
+ReactComponent renderComponent(
+  ReactComponent component,
+  DOMElement container,
+  [function callback]
+)
+```
+
+Renders a React component into the DOM in the supplied `container`.
+
+If the React component was previously rendered into `container`, this will perform an update on it and only mutate the DOM as necessary to reflect the latest React component.
+
+If the optional callback is provided, it will be executed after the component is rendered or updated.
+
+
+### React.unmountAndReleaseReactRootNode
+
+```javascript
+unmountAndReleaseReactRootNode(DOMElement container)
+```
+
+Remove a mounted React component from the DOM and clean up its event handlers and state.
+
+
+### React.renderComponentToString
+
+```javascript
+renderComponentToString(ReactComponent component, function callback)
+```
+
+Render a component to its initial HTML. This should only be used on the server. React will call `callback` with an HTML string when the markup is ready. You can use this method to can generate HTML on the server and send the markup down on the initial request for faster page loads and to allow search engines to crawl your pages for SEO purposes.
+
+If you call `React.renderComponent()` on a node that already has this server-rendered markup, React will preserve it and only attach event handlers, allowing you to have a very performant first-load experience.

docs/docs/ref-02-component-api.md

@@ -0,0 +1,109 @@
+---
+id: component-api
+title: Component API
+layout: docs
+permalink: component-api.html
+prev: top-level-api.html
+next: component-specs.html
+---
+
+## ReactComponent
+
+Component classses created by `createClass()` return instances of `ReactComponent` when called. Most of the time when you're using React you're either creating or consuming these component objects.
+
+
+### getDOMNode
+
+```javascript
+DOMElement getDOMNode()
+```
+
+If this component has been mounted into the DOM, this returns the corresponding native browser DOM element. This method is useful for reading values out of the DOM, such as form field values and performing DOM measurements.
+
+
+### setProps
+
+```javascript
+setProps(object nextProps)
+```
+
+When you're integrating with an external JavaScript application you may want to signal a change to a React component rendered with `renderComponent()`. Simply call `setProps()` to change its properties and trigger a re-render.
+
+> Note:
+>
+> This method can only be called on a root-level component. That is, it's only available on the component passed directly to `renderComponent()` and none of its children. If you're inclined to use `setProps()` on a child component, instead take advantage of reactive updates and pass the new prop to the child component when it's created in `render()`.
+
+
+### replaceProps
+
+```javascript
+replaceProps(object nextProps)
+```
+
+Like `setProps()` but deletes any pre-existing props instead of merging the two objects.
+
+
+### transferPropsTo
+
+```javascript
+ReactComponent transferPropsTo(ReactComponent targetComponent)
+```
+
+Transfer properties from this component to a target component that have not already been set on the target component. After the props are updated, `targetComponent` is returned as a convenience. This function is useful when creating simple HTML-like components:
+
+```javascript
+var Avatar = React.createClass({
+  render: function() {
+    return this.transferPropsTo(
+      <img src={"/avatars/" + this.props.userId + ".png"} userId={null} />
+    );
+  }
+});
+
+// <AvatarImage userId={17} width={200} height={200} />
+```
+
+Properties that are specified directly on the target component instance (such as `src` and `userId` in the above example) will not be overwritten by `transferPropsTo`.
+
+> Note:
+>
+> Use `transferPropsTo` with caution; it encourages tight coupling and makes it easy to accidentally introduce implicit dependencies between components. When in doubt, it's safer to explicitly copy the properties that you need onto the child component.
+
+
+### setState
+
+```javascript
+setState(object nextState[, function callback])
+```
+
+Merges nextState with the current state. This is the primary method you use to trigger UI updates from event handlers and server request callbacks.  In addition, you can supply an optional callback function that is executed once `setState` is completed.
+
+> Notes:
+>
+> *NEVER* mutate `this.state` directly, as calling `setState()` afterwards may replace the mutation you made. Treat `this.state` as if it were immutable.
+>
+> `setState()` does not immediately mutate `this.state` but creates a pending state transition. Accessing `this.state` after calling this method can potentially return the existing value.
+>
+> There is no guarantee of synchronous operation of calls to `setState` and calls may be batched for performance gains.
+
+
+### replaceState
+
+```javascript
+replaceState(object nextState[, function callback])
+```
+
+Like `setState()` but deletes any pre-existing state keys that are not in nextState.
+
+
+### forceUpdate()
+
+```javascript
+forceUpdate([function callback])
+```
+
+If your `render()` method reads from something other than `this.props` or `this.state`, you'll need to tell React when it needs to re-run `render()` by calling `forceUpdate()`. You'll also need to call `forceUpdate()` if you mutate `this.state` directly.
+
+Calling `forceUpdate()` will cause `render()` to be called on the component and its children, but React will still only update the DOM if the markup changes.
+
+Normally you should try to avoid all uses of `forceUpdate()` and only read from `this.props` and `this.state` in `render()`. This makes your application much simpler and more efficient.

docs/docs/ref-03-component-specs.md

@@ -0,0 +1,176 @@
+---
+id: component-specs
+title: Component Specs and Lifecycle
+layout: docs
+permalink: component-specs.html
+prev: component-api.html
+next: tags-and-attributes.html
+---
+
+## Component Specifications
+
+When creating a component class by invoking `React.createClass()`, you should provide a specification object that contains a `render` method and can optionally contain other lifecycle methods described here.
+
+
+### render
+
+```javascript
+ReactComponent render()
+```
+
+The `render()` method is required.
+
+When called, it should examine `this.props` and `this.state` and return a single child component. This child component can be either a native DOM component (such as `<div>`) or another composite component that you've defined yourself.
+
+The `render()` function should be *pure*, meaning that it does not modify component state, it returns the same result each time it's invoked, and it does not read from or write to the DOM or otherwise interact with the browser (e.g., by using `setTimeout`). If you need to interact with the browser, perform your work in `componentDidMount()` or the other lifecycle methods instead. Keeping `render()` pure makes server rendering more practical and makes components easier to think about.
+
+
+### getInitialState
+
+```javascript
+object getInitialState()
+```
+
+Invoked once when the component is mounted. The return value will be used as the initial value of `this.state`.
+
+
+### getDefaultProps
+
+```javascript
+object getDefaultProps()
+```
+
+Invoked once when the component is mounted. Values in the mapping will be set on `this.props` if that prop is not specified by the parent component (i.e. using an `in` check).
+
+This method is invoked before `getInitialState` and therefore cannot rely on `this.state` or use `this.setState`.
+
+
+### propTypes
+
+```javascript
+object propTypes
+```
+
+The `propTypes` object allows you to validate props being passed to your components. For more information about `propTypes`, see [Reusable Components](reusable-components.html).
+
+<!-- TODO: Document propTypes here directly. -->
+
+
+### mixins
+
+```javascript
+array mixins
+```
+
+The `mixins` array allows you to use mixins to share behavior among multiple components. For more information about mixins, see [Reusable Components](reusable-components.html).
+
+<!-- TODO: Document mixins here directly. -->
+
+
+## Lifecycle Methods
+
+Various methods are executed at specific points in a component's lifecycle.
+
+
+### Mounting: componentWillMount
+
+```javascript
+componentWillMount()
+```
+
+Invoked immediately before rendering occurs. If you call `setState` within this method, `render()` will see the updated state and will be executed only once despite the state change.
+
+
+### Mounting: componentDidMount
+
+```javascript
+componentDidMount(DOMElement rootNode)
+```
+
+Invoked immediately after rendering occurs. At this point in the lifecycle, the component has a DOM representation which you can access via the `rootNode` argument or by calling `this.getDOMNode()`.
+
+If you want to integrate with other JavaScript frameworks, set timers using `setTimeout` or `setInterval`, or send AJAX requests, perform those operations in this method.
+
+
+### Updating: componentWillReceiveProps
+
+```javascript
+componentWillReceiveProps(object nextProps)
+```
+
+Invoked when a component is receiving new props. This method is not called for the initial render.
+
+Use this as an opportunity to react to a prop transition before `render()` is called by updating the state using `this.setState()`. The old props can be accessed via `this.props`. Calling `this.setState()` within this function will not trigger an additional render.
+
+```javascript
+componentWillReceiveProps: function(nextProps) {
+  this.setState({
+    likesIncreasing: nextProps.likeCount > this.props.likeCount
+  });
+}
+```
+
+> Note:
+>
+> There is no analogous method `componentWillReceiveState`. An incoming prop transition may cause a state change, but the opposite is not true. If you need to perform operations in response to a state change, use `componentWillUpdate`.
+
+
+### Updating: shouldComponentUpdate
+
+```javascript
+boolean shouldComponentUpdate(object nextProps, object nextState)
+```
+
+Invoked before rendering when new props or state are being received. This method is not called for the initial render or when `forceUpdate` is used.
+
+Use this as an opportunity to `return false` when you're certain that the
+transition to the new props and state will not require a component update.
+
+```javascript
+shouldComponentUpdate: function(nextProps, nextState) {
+  return !equal(nextProps, this.props) || !equal(nextState, this.state);
+}
+```
+
+If `shouldComponentUpdate` returns false, then `render()` will be completely skipped until the next state change. (In addition, `componentWillUpdate` and `componentDidUpdate` will not be called.)
+
+By default, `shouldComponentUpdate` always returns true to prevent subtle bugs when `state` is mutated in place, but if you are careful to always treat `state` as immutable and to read only from `props` and `state` in `render()` then you can override `shouldComponentUpdate` with an implementation that compares the old props and state to their replacements.
+
+If performance is a bottleneck, especially with dozens or hundreds of components, use `shouldComponentUpdate` to speed up your app.
+
+
+### Updating: componentWillUpdate
+
+```javascript
+componentWillUpdate(object nextProps, object nextState)
+```
+
+Invoked immediately before rendering when new props or state are being received. This method is not called for the initial render.
+
+Use this as an opportunity to perform preparation before an update occurs.
+
+> Note:
+>
+> You *cannot* use `this.setState()` in this method. If you need to update state in response to a prop change, use `componentWillReceiveProps` instead.
+
+
+### Updating: componentDidUpdate
+
+```javascript
+componentDidUpdate(object prevProps, object prevState, DOMElement rootNode)
+```
+
+Invoked immediately after updating occurs. This method is not called for the initial render.
+
+Use this as an opportunity to operate on the DOM when the component has been updated.
+
+
+### Unmounting: componentWillUnmount
+
+```javascript
+componentWillUnmount()
+```
+
+Invoked immediately before a component is unmounted from the DOM.
+
+Perform any necessary cleanup in this method, such as invalidating timers or cleaning up any DOM elements that were created in `componentDidMount`.

docs/docs/ref-04-tags-and-attributes.md

@@ -0,0 +1,65 @@
+---
+id: tags-and-attributes
+title: Tags and Attributes
+layout: docs
+permalink: tags-and-attributes.html
+prev: component-specs.html
+next: events.html
+---
+
+## Supported Tags
+
+React attempts to support all common elements. If you need an element that isn't listed here, please file an issue.
+
+The following elements are supported:
+
+
+### HTML Elements
+
+```
+a abbr address area article aside audio b base bdi bdo big blockquote body br
+button canvas caption cite code col colgroup data datalist dd del details dfn
+div dl dt em embed fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6
+head header hr html i iframe img input ins kbd keygen label legend li link
+main map mark menu menuitem meta meter nav noscript object ol optgroup option
+output p param pre progress q rp rt ruby s samp script section select small
+source span strong style sub summary sup table tbody td textarea tfoot th
+thead time title tr track u ul var video wbr
+```
+
+### SVG elements
+
+```
+circle g line path polyline rect svg text
+```
+
+
+## Supported Attributes
+
+React supports all `data-*` and `aria-*` attributes as well as every attribute
+in the following lists. Note that all attributes are camel-cased and the attributes `class` and `for` are `className` and `htmlFor`, respectively, to match the DOM API specification.
+
+For a list of events, see [Supported Events](events.html).
+
+### HTML Attributes
+
+```
+accessKey accept action ajaxify allowFullScreen allowTransparency alt
+autoComplete autoFocus autoPlay cellPadding cellSpacing charSet checked
+className colSpan content contentEditable contextMenu controls data dateTime
+dir disabled draggable encType form frameBorder height hidden href htmlFor
+httpEquiv icon id label lang list max maxLength method min multiple name
+pattern poster preload placeholder radioGroup rel readOnly required role
+rowSpan scrollLeft scrollTop selected size spellCheck src step style tabIndex
+target title type value width wmode
+```
+
+In addition, the non-standard `autoCapitalize` attribute is supported for Mobile Safari.
+
+### SVG Attributes
+
+```
+cx cy d fill fx fy points r stroke strokeLinecap strokeWidth transform x x1 x2
+version viewBox y y1 y2 spreadMethod offset stopColor stopOpacity
+gradientUnits gradientTransform
+```

docs/docs/ref-05-events.md

@@ -0,0 +1,205 @@
+---
+id: events
+title: Event System
+layout: docs
+permalink: events.html
+prev: tags-and-attributes.html
+next: dom-differences.html
+---
+
+## SyntheticEvent
+
+Your event handlers will be passed instances of `SyntheticEvent`, a cross-browser wrapper around the browser's native event. It has the same interface as the browser's native event, including `stopPropagation()` and `preventDefault()`, except the events work identically across all browsers.
+
+If you find that you need the underlying browser event for some reason, simply use the `nativeEvent` attribute to get it. Every `SyntheticEvent` object has the following attributes:
+
+```javascript
+boolean bubbles
+boolean cancelable
+DOMEventTarget currentTarget
+boolean defaultPrevented
+Number eventPhase
+boolean isTrusted
+DOMEvent nativeEvent
+void preventDefault()
+void stopPropagation()
+DOMEventTarget target
+Date timeStamp
+String type
+```
+
+
+## Supported Events
+
+React normalizes events so that they have consistent properties across
+different browsers.
+
+
+### Clipboard Events
+
+Event names:
+
+```
+onCopy onCut onPaste
+```
+
+Properties:
+
+```javascript
+DOMDataTransfer clipboardData
+```
+
+
+### Keyboard Events
+
+Event names:
+
+```
+onKeyDown onKeyPress onKeyUp
+```
+
+Properties:
+
+```javascript
+boolean altKey
+String char
+boolean ctrlKey
+String key
+String locale
+Number location
+boolean metaKey
+boolean repeat
+boolean shiftKey
+```
+
+
+### Focus Events
+
+Event names:
+
+```
+onFocus onBlur
+```
+
+Properties:
+
+```javascript
+DOMEventTarget relatedTarget
+```
+
+
+### Form Events
+
+Event names:
+
+```
+onChange onInput onSubmit
+```
+
+For more information about the onChange event, see [Forms](forms.html).
+
+
+### Mouse Events
+
+Event names:
+
+```
+onClick onDoubleClick onDrag onDragEnd onDragEnter onDragExit onDragLeave
+onDragOver onDragStart onDrop onMouseDown onMouseEnter onMouseLeave
+onMouseMove onMouseUp
+```
+
+Properties: 
+
+```javascript
+boolean altKey
+Number button
+Number buttons
+Number clientX
+Number clientY
+boolean ctrlKey
+boolean metaKey
+Number pageX
+Number pageY
+DOMEventTarget relatedTarget
+Number screenX
+Number screenY
+boolean shiftKey
+```
+
+
+### Mutation Events
+
+Event names:
+
+```
+onDOMCharacterDataModified
+```
+
+Properties:
+
+```javascript
+Number attrChange
+String attrName
+String newValue
+String prevValue
+Node relatedNode
+```
+
+
+### Touch events
+
+To enable touch events, call `React.initializeTouchEvents(true)` before
+rendering any component.
+
+Event names:
+
+```
+onTouchCancel onTouchEnd onTouchMove onTouchStart
+```
+
+Properties:
+
+```javascript
+boolean altKey
+DOMTouchList changedTouches
+boolean ctrlKey
+boolean metaKey
+boolean shiftKey
+DOMTouchList targetTouches
+DOMTouchList touches
+```
+
+
+### UI Events
+
+Event names:
+
+```
+onScroll
+```
+
+Properties:
+
+```javascript
+Number detail
+DOMAbstractView view
+```
+
+
+### Wheel Events
+
+Event names:
+
+```
+onWheel
+```
+
+Properties:
+
+```javascript
+Number deltaX
+Number deltaMode
+Number deltaY
+Number deltaZ
+```

docs/docs/ref-06-dom-differences.md

@@ -0,0 +1,14 @@
+---
+id: dom-differences
+title: DOM Differences
+layout: docs
+permalink: dom-differences.html
+prev: events.html
+---
+
+React has implemented a browser-independent events and DOM system for performance and cross-browser compatibility reasons. We took the opportunity to clean up a few rough edges in browser DOM implementations.
+
+* All DOM properties and attributes (including event handlers) should be camelCased to be consistent with standard JavaScript style. We intentionally break with the spec here since the spec is inconsistent.
+* The `style` attribute accepts a JavaScript object with camelCased properties rather than a CSS string. This is consistent with the DOM `style` JavaScript property, is more efficient, and prevents XSS security holes.
+* All event objects conform to the W3C spec, and all events (including submit) bubble correctly per the W3C spec. See [Event System](events.html) for more details.
+* The `onChange` event behaves as you would expect it to: whenever a form field is changed this event is fired rather than inconsistently on blur. We intentionally break from existing browser behavior because `onChange` is a misnomer for its behavior and React relies on this event to react to user input in real time. See [Forms](forms.html) for more details.

docs/docs/reference.html

@@ -0,0 +1,4 @@
+---
+layout: redirect
+destination: top-level-api.html
+---

docs/docs/tutorial.md

@@ -99,7 +99,7 @@ React.renderComponent(
 );
 ```
 
-Its use is optional but we've found JSX syntax easier to use than plain JavaScript. Read more on the [JSX Syntax article](syntax.html).
+Its use is optional but we've found JSX syntax easier to use than plain JavaScript. Read more on the [JSX Syntax article](jsx-in-depth.html).
 
 #### What's going on
 
@@ -107,7 +107,7 @@ We pass some methods in a JavaScript object to `React.createClass()` to create a
 
 The `<div>` tags are not actual DOM nodes; they are instantiations of React `div` components. You can think of these as markers or pieces of data that React knows how to handle. React is **safe**. We are not generating HTML strings so XSS protection is the default.
 
-You do not have to return basic HTML. You can return a tree of components that you (or someone else built). This is what makes React **composable**: a key tenet of maintainable frontends.
+You do not have to return basic HTML. You can return a tree of components that you (or someone else) built. This is what makes React **composable**: a key tenet of maintainable frontends.
 
 `React.renderComponent()` instantiates the root component, starts the framework, and injects the markup into a raw DOM element, provided as the second argument.
 
@@ -203,7 +203,17 @@ By surrounding a JavaScript expression in braces inside JSX (as either an attrib
 
 Markdown is a simple way to format your text inline. For example, surrounding text with asterisks will make it emphasized.
 
-First, add the third-party **Showdown** library to your application. This is a JavaScript library which takes Markdown text and converts it to raw HTML. This requires a script tag in your head (which we have already included in the React playground).
+First, add the third-party **Showdown** library to your application. This is a JavaScript library which takes Markdown text and converts it to raw HTML. This requires a script tag in your head (which we have already included in the React playground):
+
+```html{6}
+<!-- template.html -->
+<head>
+  <title>Hello React</title>
+  <script src="http://fb.me/react-{{site.react_version}}.js"></script>
+  <script src="http://fb.me/JSXTransformer-{{site.react_version}}.js"></script>
+  <script src="http://cdnjs.cloudflare.com/ajax/libs/showdown/0.3.1/showdown.min.js"></script>
+</head>
+```
 
 Next, let's convert the comment text to Markdown and output it:
 
@@ -314,7 +324,7 @@ Let's replace the hard-coded data with some dynamic data from the server. We wil
 // tutorial11.js
 React.renderComponent(
   <CommentBox url="comments.json" />,
-  document.getElementById('example')
+  document.getElementById('content')
 );
 ```
 
@@ -438,7 +448,7 @@ All we have done here is move the AJAX call to a separate method and call it whe
 
 Now it's time to build the form. Our `CommentForm` component should ask the user for their name and comment text and send a request to the server to save the comment.
 
-```javascript{5-8}
+```javascript{5-9}
 // tutorial15.js
 var CommentForm = React.createClass({
   render: function() {
@@ -489,7 +499,7 @@ var CommentForm = React.createClass({
 
 React attaches event handlers to components using a camelCase naming convention. We attach an `onSubmit` handler to the form that clears the form fields when the form is submitted with valid input.
 
-We always return `false` from the event handler to prevent the browser's default action of submitting the form. (If you prefer, you can instead take the event as an argument and call `preventDefault()` on it &ndash; read more about [event handling](event-handling.html).)
+We always return `false` from the event handler to prevent the browser's default action of submitting the form. (If you prefer, you can instead take the event as an argument and call `preventDefault()` on it.)
 
 ##### Refs
 
@@ -677,4 +687,4 @@ var CommentBox = React.createClass({
 
 ### Congrats!
 
-You have just built a comment box in a few simple steps. Learn more about React in the [reference](syntax.html) or start hacking! Good luck!
+You have just built a comment box in a few simple steps. Learn more about [why to use React](why-react.html), or dive into the [API reference](top-level-api.html) and start hacking! Good luck!

docs/downloads.md

@@ -29,12 +29,14 @@ The uncompressed, development version of React core with inline documentation.
 ```
 
 #### <a href="http://fb.me/JSXTransformer-{{site.react_version}}.js">JSX Transform</a>
-The JSX transformer used to support [XML syntax](/react/docs/syntax.html) in JavaScript.
+The JSX transformer used to support [XML syntax](/react/docs/jsx-in-depth.html) in JavaScript.
 
 ```html
 <script src="http://fb.me/JSXTransformer-{{site.react_version}}.js"></script>
 ```
 
+All scripts are also available via [CDNJS](http://cdnjs.com/#react).
+
 ## Bower
 
 ```sh

docs/jsx-compiler.md

@@ -6,7 +6,7 @@ id: jsx-compiler
 <div class="jsxCompiler">
   <h1>JSX Compiler</h1>
   <p>
-    This tool demonstrates how <a href="/react/docs/syntax.html">JSX syntax</a>
+    This tool demonstrates how <a href="/react/docs/jsx-in-depth.html">JSX syntax</a>
     is desguared into native JavaScript.
   </p>
   <div id="jsxCompiler"></div>

docs/support.md

@@ -6,9 +6,13 @@ id: support
 
 **React** is worked on full-time by Facebook's product infrastructure and Instagram's user interface engineering teams. They're often around and available for questions.
 
+## Stack Overflow
+
+Many members of the community use Stack Overflow to ask questions. Read through the [existing questions](http://stackoverflow.com/questions/tagged/reactjs) tagged with **reactjs** or [ask your own](http://stackoverflow.com/questions/ask)!
+
 ## Google Groups mailing list
 
-<a href="http://groups.google.com/group/reactjs" target="_blank">The **reactjs** Google Group</a> is the best place to ask questions and find answers.
+<a href="http://groups.google.com/group/reactjs" target="_blank">The **reactjs** Google Group</a> is also a good place to ask questions and find answers.
 
 ## IRC
 

examples/ballmer-peak/example.js

@@ -14,8 +14,8 @@ var BallmerPeakCalculator = React.createClass({
   getInitialState: function() {
     return {bac: 0};
   },
-  handleChange: function() {
-    this.setState({bac: this.refs.bac.getDOMNode().value});
+  handleChange: function(event) {
+    this.setState({bac: event.target.value});
   },
   render: function() {
     var bac;
@@ -33,7 +33,7 @@ var BallmerPeakCalculator = React.createClass({
         <h4>Compute your Ballmer Peak:</h4>
         <p>
           If your BAC is{' '}
-          <input ref="bac" type="text" onInput={this.handleChange} value={this.state.bac} />
+          <input type="text" onChange={this.handleChange} value={this.state.bac} />
           {', '}then <b>{pct}</b> of your lines of code will have bugs.
         </p>
       </div>

examples/ballmer-peak/index.html

@@ -14,7 +14,7 @@
         <pre>
           python -m SimpleHTTPServer
         </pre>
-        and going to <a href="http://localhost:8080/">http://localhost:8080/</a>.
+        and going to <a href="http://localhost:8000/">http://localhost:8000/</a>.
       </p>
     </div>
     <h4>Example Details</h4>

examples/basic-jsx-external/index.html

@@ -54,7 +54,7 @@
             <pre id="chromeServerCLI" class="codeBox">
 cd /Path/To/This/File
 python -m SimpleHTTPServer
-open -a "Google Chrome"  <a href="http://localhost:8080/">http://localhost:8080/</a>.  </pre>
+open -a "Google Chrome"  <a href="http://localhost:8000/">http://localhost:8000/</a>.  </pre>
           </li>
         </ol>
         <h4 id="chromeErrorFooter" style="color: #733"></h4>

examples/basic-jsx-precompile/index.html

@@ -10,7 +10,7 @@
     <div id="container">
       <p>
         To install React, follow the instructions on
-        <a href="http://www.github.com/facebook/react.js/">GitHub</a>.
+        <a href="http://www.github.com/facebook/react/">GitHub</a>.
       </p>
       <p>
         If you can see this, React is not running. You probably didn't run:

examples/basic-jsx/index.html

@@ -10,7 +10,7 @@
     <div id="container">
       <p>
         To install React, follow the instructions on
-        <a href="http://www.github.com/facebook/react.js/">GitHub</a>.
+        <a href="http://www.github.com/facebook/react/">GitHub</a>.
       </p>
       <p>
         If you can see this, React is not working right.

examples/basic/index.html

@@ -10,7 +10,7 @@
     <div id="container">
       <p>
         To install React, follow the instructions on
-        <a href="http://www.github.com/facebook/react.js/">GitHub</a>.
+        <a href="http://www.github.com/facebook/react/">GitHub</a>.
       </p>
       <p>
         If you can see this, React is not working right.

examples/jquery-bootstrap/js/app.js

@@ -7,7 +7,7 @@ var BootstrapButton = React.createClass({
     // transferPropsTo() is smart enough to merge classes provided
     // to this component.
     return this.transferPropsTo(
-      <a href="javascript:;" role="button" class="btn">
+      <a href="javascript:;" role="button" className="btn">
         {this.props.children}
       </a>
     );
@@ -19,12 +19,18 @@ var BootstrapModal = React.createClass({
   // integrate with Bootstrap or jQuery!
   componentDidMount: function() {
     // When the component is added, turn it into a modal
-    $(this.getDOMNode()).modal({backdrop: 'static', keyboard: false});
+    $(this.getDOMNode())
+      .modal({backdrop: 'static', keyboard: false, show: false})
   },
   componentWillUnmount: function() {
-    // And when it's destroyed, hide it.
+    $(this.getDOMNode()).off('hidden', this.handleHidden);
+  },
+  close: function() {
     $(this.getDOMNode()).modal('hide');
   },
+  open: function() {
+    $(this.getDOMNode()).modal('show');
+  },
   render: function() {
     var confirmButton = null;
     var cancelButton = null;
@@ -32,92 +38,84 @@ var BootstrapModal = React.createClass({
     if (this.props.confirm) {
       confirmButton = (
         <BootstrapButton
-          onClick={this.onConfirm}
-          class="btn-primary">
+          onClick={this.handleConfirm}
+          className="btn-primary">
           {this.props.confirm}
         </BootstrapButton>
       );
     }
     if (this.props.cancel) {
       cancelButton = (
-        <BootstrapButton onClick={this.onCancel}>
+        <BootstrapButton onClick={this.handleCancel}>
           {this.props.cancel}
         </BootstrapButton>
       );
     }
 
     return (
-      <div class="modal hide fade">
-        <div class="modal-header">
+      <div className="modal hide fade">
+        <div className="modal-header">
           <button
             type="button"
-            class="close"
-            onClick={this.onCancel}
-            dangerouslyInsertInnerHtml={{__html: '&times;'}}
+            className="close"
+            onClick={this.handleCancel}
+            dangerouslySetInnerHTML={{__html: '&times'}}
           />
           <h3>{this.props.title}</h3>
         </div>
-        <div class="modal-body">
+        <div className="modal-body">
           {this.props.children}
         </div>
-        <div class="modal-footer">
+        <div className="modal-footer">
           {cancelButton}
           {confirmButton}
         </div>
       </div>
     );
   },
-  onCancel: function() {
+  handleCancel: function() {
     if (this.props.onCancel) {
       this.props.onCancel();
     }
-    this.close();
   },
-  onConfirm: function() {
+  handleConfirm: function() {
     if (this.props.onConfirm) {
       this.props.onConfirm();
     }
-    this.close();
-  },
-  close: function() {
-    if (this.props.onClose) {
-      this.props.onClose();
-    }
   }
 });
 
 var Example = React.createClass({
-  getInitialState: function() {
-    return {modalVisible: false};
-  },
-  toggleModal: function() {
-    this.setState({modalVisible: !this.state.modalVisible});
-  },
   handleCancel: function() {
     if (confirm('Are you sure you want to cancel?')) {
-      this.toggleModal();
+      this.refs.modal.close();
     }
   },
   render: function() {
     var modal = null;
-    if (this.state.modalVisible) {
-      modal = (
-        <BootstrapModal
-          confirm="OK"
-          cancel="Cancel"
-          onCancel={this.handleCancel}
-          onConfirm={this.toggleModal}
-          title="Hello, Bootstrap!">
-            This is a React component powered by jQuery and Bootstrap!
-        </BootstrapModal>
-      );
-    }
+    modal = (
+      <BootstrapModal
+        ref="modal"
+        confirm="OK"
+        cancel="Cancel"
+        onCancel={this.handleCancel}
+        onConfirm={this.closeModal}
+        title="Hello, Bootstrap!">
+          This is a React component powered by jQuery and Bootstrap!
+      </BootstrapModal>
+    );
     return (
-      <div class="example">
+      <div className="example">
         {modal}
-        <BootstrapButton onClick={this.toggleModal}>Toggle modal</BootstrapButton>
+        <BootstrapButton onClick={this.openModal}>Open modal</BootstrapButton>
       </div>
     );
+  },
+  openModal: function() {
+    this.refs.modal.open();
+  },
+  closeModal: function() {
+    this.refs.modal.close();
   }
 });
 

examples/wrapup/index.html

@@ -10,7 +10,7 @@
     <div id="container">
       <p>
         To install React, follow the instructions on
-        <a href="http://www.github.com/facebook/react.js/">GitHub</a>.
+        <a href="http://www.github.com/facebook/react/">GitHub</a>.
       </p>
       <p>
         If you can see this, React is not working right.

grunt/config/populist.js

@@ -11,7 +11,7 @@ var jasmine = {
 
 var test = {
   rootDirectory: "build/modules",
-  args: ["test/all:"],
+  args: ["test/all:harness"],
   requires: [
     "**/__tests__/*-test.js"
   ],

package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-tools",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "keywords": [
     "react",
     "jsx",
@@ -20,6 +20,7 @@
     "main.js",
     "bin/jsx",
     "build/modules/",
+    "src/",
     "vendor/fbtransform/",
     "vendor/constants.js"
   ],
@@ -32,7 +33,7 @@
     "url": "https://github.com/facebook/react"
   },
   "scripts": {
-    "test": "grunt test"
+    "test": "grunt build && grunt test"
   },
   "dependencies": {
     "base62": "~0.1.1",

react-source.gemspec

@@ -8,7 +8,7 @@ gemspec = Gem::Specification.new do |s|
   s.version = package['version']
   s.license = 'Apache-2.0'
 
-  s.homepage = 'https://github.com/facebook/react.js'
+  s.homepage = 'https://github.com/facebook/react'
   s.summary = 'Ruby bridge to JSX & the React JavaScript library.'
 
   s.authors = ['Paul O’Shannessy']

src/core/ReactComponent.js

@@ -20,9 +20,10 @@
 
 "use strict";
 
+var getReactRootElementInContainer = require('getReactRootElementInContainer');
 var ReactCurrentOwner = require('ReactCurrentOwner');
 var ReactDOMIDOperations = require('ReactDOMIDOperations');
-var ReactID = require('ReactID');
+var ReactMarkupChecksum = require('ReactMarkupChecksum');
 var ReactMount = require('ReactMount');
 var ReactOwner = require('ReactOwner');
 var ReactReconcileTransaction = require('ReactReconcileTransaction');
@@ -255,7 +256,7 @@ var ReactComponent = {
         this.isMounted(),
         'getDOMNode(): A component must be mounted to have a DOM node.'
       );
-      return ReactID.getNode(this._rootNodeID);
+      return ReactMount.getNode(this._rootNodeID);
     },
 
     /**
@@ -381,7 +382,7 @@ var ReactComponent = {
       if (props.ref != null) {
         ReactOwner.removeComponentAsRefFrom(this, props.ref, props[OWNER]);
       }
-      ReactID.purgeID(this._rootNodeID);
+      ReactMount.purgeID(this._rootNodeID);
       this._rootNodeID = null;
       this._lifeCycleState = ComponentLifeCycle.UNMOUNTED;
     },
@@ -498,15 +499,28 @@ var ReactComponent = {
         container && container.nodeType === 1,
         'mountComponentIntoNode(...): Target container is not a DOM element.'
       );
-      var renderStart = Date.now();
       var markup = this.mountComponent(rootID, transaction);
-      ReactMount.totalInstantiationTime += (Date.now() - renderStart);
 
       if (shouldReuseMarkup) {
-        return;
+        if (ReactMarkupChecksum.canReuseMarkup(
+              markup,
+              getReactRootElementInContainer(container))) {
+          return;
+        } else {
+          if (__DEV__) {
+            console.warn(
+              'React attempted to use reuse markup in a container but the ' +
+              'checksum was invalid. This generally means that you are using ' +
+              'server rendering and the markup generated on the server was ' +
+              'not what the client was expecting. React injected new markup ' +
+              'to compensate which works but you have lost many of the ' +
+              'benefits of server rendering. Instead, figure out why the ' +
+              'markup being generated is different on the client or server.'
+            );
+          }
+        }
       }
 
-      var injectionStart = Date.now();
       // Asynchronously inject markup by ensuring that the container is not in
       // the document when settings its `innerHTML`.
       var parent = container.parentNode;
@@ -522,7 +536,6 @@ var ReactComponent = {
       } else {
         container.innerHTML = markup;
       }
-      ReactMount.totalInjectionTime += (Date.now() - injectionStart);
     },
 
     /**

src/core/ReactDOMIDOperations.js

@@ -24,7 +24,7 @@
 var CSSPropertyOperations = require('CSSPropertyOperations');
 var DOMChildrenOperations = require('DOMChildrenOperations');
 var DOMPropertyOperations = require('DOMPropertyOperations');
-var ReactID = require('ReactID');
+var ReactMount = require('ReactMount');
 
 var getTextContentAccessor = require('getTextContentAccessor');
 var invariant = require('invariant');
@@ -65,13 +65,21 @@ var ReactDOMIDOperations = {
    * @internal
    */
   updatePropertyByID: function(id, name, value) {
-    var node = ReactID.getNode(id);
+    var node = ReactMount.getNode(id);
     invariant(
       !INVALID_PROPERTY_ERRORS.hasOwnProperty(name),
       'updatePropertyByID(...): %s',
       INVALID_PROPERTY_ERRORS[name]
     );
-    DOMPropertyOperations.setValueForProperty(node, name, value);
+
+    // If we're updating to null or undefined, we should remove the property
+    // from the DOM node instead of inadvertantly setting to a string. This
+    // brings us in line with the same behavior we have on initial render.
+    if (value != null) {
+      DOMPropertyOperations.setValueForProperty(node, name, value);
+    } else {
+      DOMPropertyOperations.deleteValueForProperty(node, name);
+    }
   },
 
   /**
@@ -83,7 +91,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   deletePropertyByID: function(id, name, value) {
-    var node = ReactID.getNode(id);
+    var node = ReactMount.getNode(id);
     invariant(
       !INVALID_PROPERTY_ERRORS.hasOwnProperty(name),
       'updatePropertyByID(...): %s',
@@ -120,7 +128,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   updateStylesByID: function(id, styles) {
-    var node = ReactID.getNode(id);
+    var node = ReactMount.getNode(id);
     CSSPropertyOperations.setValueForStyles(node, styles);
   },
 
@@ -132,7 +140,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   updateInnerHTMLByID: function(id, html) {
-    var node = ReactID.getNode(id);
+    var node = ReactMount.getNode(id);
     // HACK: IE8- normalize whitespace in innerHTML, removing leading spaces.
     // @see quirksmode.org/bugreports/archives/2004/11/innerhtml_and_t.html
     node.innerHTML = (html && html.__html || '').replace(/^ /g, ' ');
@@ -146,7 +154,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   updateTextContentByID: function(id, content) {
-    var node = ReactID.getNode(id);
+    var node = ReactMount.getNode(id);
     node[textContentAccessor] = content;
   },
 
@@ -159,7 +167,7 @@ var ReactDOMIDOperations = {
    * @see {Danger.dangerouslyReplaceNodeWithMarkup}
    */
   dangerouslyReplaceNodeWithMarkupByID: function(id, markup) {
-    var node = ReactID.getNode(id);
+    var node = ReactMount.getNode(id);
     DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup(node, markup);
   },
 
@@ -168,7 +176,7 @@ var ReactDOMIDOperations = {
    *       Detect if any elements were removed instead of blindly purging.
    */
   manageChildrenByParentID: function(parentID, domOperations) {
-    var parent = ReactID.getNode(parentID);
+    var parent = ReactMount.getNode(parentID);
     DOMChildrenOperations.manageChildren(parent, domOperations);
   }
 

src/core/ReactDefaultInjection.js

@@ -24,6 +24,8 @@ var ReactDOMInput = require('ReactDOMInput');
 var ReactDOMOption = require('ReactDOMOption');
 var ReactDOMSelect = require('ReactDOMSelect');
 var ReactDOMTextarea = require('ReactDOMTextarea');
+var ReactEventEmitter = require('ReactEventEmitter');
+var ReactEventTopLevelCallback = require('ReactEventTopLevelCallback');
 
 var DefaultDOMPropertyConfig = require('DefaultDOMPropertyConfig');
 var DOMProperty = require('DOMProperty');
@@ -34,8 +36,10 @@ var ChangeEventPlugin = require('ChangeEventPlugin');
 var EventPluginHub = require('EventPluginHub');
 var ReactInstanceHandles = require('ReactInstanceHandles');
 var SimpleEventPlugin = require('SimpleEventPlugin');
+var MobileSafariClickEventPlugin = require('MobileSafariClickEventPlugin');
 
 function inject() {
+  ReactEventEmitter.TopLevelCallbackCreator = ReactEventTopLevelCallback;
   /**
    * Inject module for resolving DOM hierarchy and plugin ordering.
    */
@@ -49,7 +53,8 @@ function inject() {
   EventPluginHub.injection.injectEventPluginsByName({
     'SimpleEventPlugin': SimpleEventPlugin,
     'EnterLeaveEventPlugin': EnterLeaveEventPlugin,
-    'ChangeEventPlugin': ChangeEventPlugin
+    'ChangeEventPlugin': ChangeEventPlugin,
+    'MobileSafariClickEventPlugin': MobileSafariClickEventPlugin
   });
 
   ReactDOM.injection.injectComponentClasses({

src/core/ReactEventEmitter.js

@@ -244,7 +244,7 @@ var ReactEventEmitter = {
 
   /**
    * React references `ReactEventTopLevelCallback` using this property in order
-   * to allow dependency injection via `ensureListening`.
+   * to allow dependency injection.
    */
   TopLevelCallbackCreator: null,
 
@@ -257,17 +257,20 @@ var ReactEventEmitter = {
    * reason, and only in some cases).
    *
    * @param {boolean} touchNotMouse Listen to touch events instead of mouse.
-   * @param {object} TopLevelCallbackCreator
    */
-  ensureListening: function(touchNotMouse, TopLevelCallbackCreator) {
+  ensureListening: function(touchNotMouse) {
     invariant(
       ExecutionEnvironment.canUseDOM,
       'ensureListening(...): Cannot toggle event listening in a Worker ' +
       'thread. This is likely a bug in the framework. Please report ' +
       'immediately.'
     );
+    invariant(
+      ReactEventEmitter.TopLevelCallbackCreator,
+      'ensureListening(...): Cannot be called without a top level callback ' +
+      'creator being injected.'
+    );
     if (!_isListening) {
-      ReactEventEmitter.TopLevelCallbackCreator = TopLevelCallbackCreator;
       listenAtTopLevel(touchNotMouse);
       _isListening = true;
     }

src/core/ReactEventTopLevelCallback.js

@@ -21,8 +21,7 @@
 
 var ExecutionEnvironment = require('ExecutionEnvironment');
 var ReactEventEmitter = require('ReactEventEmitter');
-var ReactID = require('ReactID');
-var ReactInstanceHandles = require('ReactInstanceHandles');
+var ReactMount = require('ReactMount');
 
 var getEventTarget = require('getEventTarget');
 
@@ -34,7 +33,7 @@ var _topLevelListenersEnabled = true;
 
 /**
  * Top-level callback creator used to implement event handling using delegation.
- * This is used via dependency injection in `ReactEventEmitter.ensureListening`.
+ * This is used via dependency injection.
  */
 var ReactEventTopLevelCallback = {
 
@@ -73,10 +72,10 @@ var ReactEventTopLevelCallback = {
           nativeEvent.srcElement !== nativeEvent.target) {
         nativeEvent.target = nativeEvent.srcElement;
       }
-      var topLevelTarget = ReactInstanceHandles.getFirstReactDOM(
+      var topLevelTarget = ReactMount.getFirstReactDOM(
         getEventTarget(nativeEvent)
       ) || ExecutionEnvironment.global;
-      var topLevelTargetID = ReactID.getID(topLevelTarget) || '';
+      var topLevelTargetID = ReactMount.getID(topLevelTarget) || '';
       ReactEventEmitter.handleTopLevel(
         topLevelType,
         topLevelTarget,

src/core/ReactID.js

@@ -1,166 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactID
- * @typechecks static-only
- */
-
-"use strict";
-
-var invariant = require('invariant');
-var ReactMount = require('ReactMount');
-var ATTR_NAME = 'data-reactid';
-var nodeCache = {};
-
-/**
- * Accessing node[ATTR_NAME] or calling getAttribute(ATTR_NAME) on a form
- * element can return its control whose name or ID equals ATTR_NAME. All
- * DOM nodes support `getAttributeNode` but this can also get called on
- * other objects so just return '' if we're given something other than a
- * DOM node (such as window).
- *
- * @param {?DOMElement|DOMWindow|DOMDocument|DOMTextNode} node DOM node.
- * @return {string} ID of the supplied `domNode`.
- */
-function getID(node) {
-  var id = internalGetID(node);
-  if (id) {
-    if (nodeCache.hasOwnProperty(id)) {
-      var cached = nodeCache[id];
-      if (cached !== node) {
-        invariant(
-          !isValid(cached, id),
-          'ReactID: Two valid but unequal nodes with the same `%s`: %s',
-          ATTR_NAME, id
-        );
-
-        nodeCache[id] = node;
-      }
-    } else {
-      nodeCache[id] = node;
-    }
-  }
-
-  return id;
-}
-
-function internalGetID(node) {
-  if (node && node.getAttributeNode) {
-    var attributeNode = node.getAttributeNode(ATTR_NAME);
-    if (attributeNode) {
-      return attributeNode.value || '';
-    }
-  }
-  return '';
-}
-
-/**
- * Sets the React-specific ID of the given node.
- *
- * @param {DOMElement} node The DOM node whose ID will be set.
- * @param {string} id The value of the ID attribute.
- */
-function setID(node, id) {
-  var oldID = internalGetID(node);
-  if (oldID !== id) {
-    delete nodeCache[oldID];
-  }
-  node.setAttribute(ATTR_NAME, id);
-  nodeCache[id] = node;
-}
-
-/**
- * Finds the node with the supplied React-generated DOM ID.
- *
- * @param {string} id A React-generated DOM ID.
- * @return {DOMElement} DOM node with the suppled `id`.
- * @internal
- */
-function getNode(id) {
-  if (!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id], id)) {
-    nodeCache[id] = ReactMount.findReactNodeByID(id);
-  }
-  return nodeCache[id];
-}
-
-/**
- * A node is "valid" if it is contained by a currently mounted container.
- *
- * This means that the node does not have to be contained by a document in
- * order to be considered valid.
- *
- * @param {?DOMElement} node The candidate DOM node.
- * @param {string} id The expected ID of the node.
- * @return {boolean} Whether the node is contained by a mounted container.
- */
-function isValid(node, id) {
-  if (node) {
-    invariant(
-      internalGetID(node) === id,
-      'ReactID: Unexpected modification of `%s`',
-      ATTR_NAME
-    );
-
-    var container = ReactMount.findReactContainerForID(id);
-    if (container && contains(container, node)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function contains(ancestor, descendant) {
-  if (ancestor.contains) {
-    // Supported natively in virtually all browsers, but not in jsdom.
-    return ancestor.contains(descendant);
-  }
-
-  if (descendant === ancestor) {
-    return true;
-  }
-
-  if (descendant.nodeType === 3) {
-    // If descendant is a text node, start from descendant.parentNode
-    // instead, so that we can assume all ancestors worth considering are
-    // element nodes with nodeType === 1.
-    descendant = descendant.parentNode;
-  }
-
-  while (descendant && descendant.nodeType === 1) {
-    if (descendant === ancestor) {
-      return true;
-    }
-    descendant = descendant.parentNode;
-  }
-
-  return false;
-}
-
-/**
- * Causes the cache to forget about one React-specific ID.
- *
- * @param {string} id The ID to forget.
- */
-function purgeID(id) {
-  delete nodeCache[id];
-}
-
-exports.ATTR_NAME = ATTR_NAME;
-exports.getID = getID;
-exports.rawGetID = internalGetID;
-exports.setID = setID;
-exports.getNode = getNode;
-exports.purgeID = purgeID;

src/core/ReactInstanceHandles.js

@@ -19,8 +19,6 @@
 
 "use strict";
 
-var ReactID = require('ReactID');
-
 var invariant = require('invariant');
 
 var SEPARATOR = '.';
@@ -239,103 +237,6 @@ var ReactInstanceHandles = {
     );
   },
 
-  /**
-   * True if the supplied `node` is rendered by React.
-   *
-   * @param {*} node DOM Element to check.
-   * @return {boolean} True if the DOM Element appears to be rendered by React.
-   * @internal
-   */
-  isRenderedByReact: function(node) {
-    if (node.nodeType !== 1) {
-      // Not a DOMElement, therefore not a React component
-      return false;
-    }
-    var id = ReactID.getID(node);
-    return id ? id.charAt(0) === SEPARATOR : false;
-  },
-
-  /**
-   * Traverses up the ancestors of the supplied node to find a node that is a
-   * DOM representation of a React component.
-   *
-   * @param {*} node
-   * @return {?DOMEventTarget}
-   * @internal
-   */
-  getFirstReactDOM: function(node) {
-    var current = node;
-    while (current && current.parentNode !== current) {
-      if (ReactInstanceHandles.isRenderedByReact(current)) {
-        return current;
-      }
-      current = current.parentNode;
-    }
-    return null;
-  },
-
-  /**
-   * Finds a node with the supplied `id` inside of the supplied `ancestorNode`.
-   * Exploits the ID naming scheme to perform the search quickly.
-   *
-   * @param {DOMEventTarget} ancestorNode Search from this root.
-   * @pararm {string} id ID of the DOM representation of the component.
-   * @return {DOMEventTarget} DOM node with the supplied `id`.
-   * @internal
-   */
-  findComponentRoot: function(ancestorNode, id) {
-    var firstChildren = [ancestorNode.firstChild];
-    var childIndex = 0;
-
-    while (childIndex < firstChildren.length) {
-      var child = firstChildren[childIndex++];
-      while (child) {
-        var childID = ReactID.getID(child);
-        if (childID) {
-          if (id === childID) {
-            return child;
-          } else if (isAncestorIDOf(childID, id)) {
-            // If we find a child whose ID is an ancestor of the given ID,
-            // then we can be sure that we only want to search the subtree
-            // rooted at this child, so we can throw out the rest of the
-            // search state.
-            firstChildren.length = childIndex = 0;
-            firstChildren.push(child.firstChild);
-            break;
-          } else {
-            // TODO This should not be necessary if the ID hierarchy is
-            // correct, but is occasionally necessary if the DOM has been
-            // modified in unexpected ways.
-            firstChildren.push(child.firstChild);
-          }
-        } else {
-          // If this child had no ID, then there's a chance that it was
-          // injected automatically by the browser, as when a `<table>`
-          // element sprouts an extra `<tbody>` child as a side effect of
-          // `.innerHTML` parsing. Optimistically continue down this
-          // branch, but not before examining the other siblings.
-          firstChildren.push(child.firstChild);
-        }
-        child = child.nextSibling;
-      }
-    }
-
-    if (__DEV__) {
-      console.error(
-        'Error while invoking `findComponentRoot` with the following ' +
-        'ancestor node:',
-        ancestorNode
-      );
-    }
-    invariant(
-      false,
-      'findComponentRoot(..., %s): Unable to find element. This probably ' +
-      'means the DOM was unexpectedly mutated (e.g. by the browser).',
-      id,
-      ReactID.getID(ancestorNode)
-    );
-  },
-
   /**
    * Gets the DOM ID of the React component that is the root of the tree that
    * contains the React component with the supplied DOM ID.
@@ -400,7 +301,11 @@ var ReactInstanceHandles = {
    * Exposed for unit testing.
    * @private
    */
-  _getNextDescendantID: getNextDescendantID
+  _getNextDescendantID: getNextDescendantID,
+
+  isAncestorIDOf: isAncestorIDOf,
+
+  SEPARATOR: SEPARATOR
 
 };
 

src/core/ReactMount.js

@@ -19,10 +19,14 @@
 "use strict";
 
 var invariant = require('invariant');
+var getReactRootElementInContainer = require('getReactRootElementInContainer');
 var ReactEventEmitter = require('ReactEventEmitter');
 var ReactInstanceHandles = require('ReactInstanceHandles');
-var ReactEventTopLevelCallback = require('ReactEventTopLevelCallback');
-var ReactID = require('ReactID');
+
+var SEPARATOR = ReactInstanceHandles.SEPARATOR;
+
+var ATTR_NAME = 'data-reactid';
+var nodeCache = {};
 
 var $ = require('$');
 
@@ -37,21 +41,144 @@ if (__DEV__) {
   var rootElementsByReactRootID = {};
 }
 
-/**
- * @param {DOMElement} container DOM element that may contain a React component
- * @return {?*} DOM element that may have the reactRoot ID, or null.
- */
-function getReactRootElementInContainer(container) {
-  return container && container.firstChild;
-}
-
 /**
  * @param {DOMElement} container DOM element that may contain a React component.
  * @return {?string} A "reactRoot" ID, if a React component is rendered.
  */
 function getReactRootID(container) {
   var rootElement = getReactRootElementInContainer(container);
-  return rootElement && ReactID.getID(rootElement);
+  return rootElement && ReactMount.getID(rootElement);
+}
+
+/**
+ * Accessing node[ATTR_NAME] or calling getAttribute(ATTR_NAME) on a form
+ * element can return its control whose name or ID equals ATTR_NAME. All
+ * DOM nodes support `getAttributeNode` but this can also get called on
+ * other objects so just return '' if we're given something other than a
+ * DOM node (such as window).
+ *
+ * @param {?DOMElement|DOMWindow|DOMDocument|DOMTextNode} node DOM node.
+ * @return {string} ID of the supplied `domNode`.
+ */
+function getID(node) {
+  var id = internalGetID(node);
+  if (id) {
+    if (nodeCache.hasOwnProperty(id)) {
+      var cached = nodeCache[id];
+      if (cached !== node) {
+        invariant(
+          !isValid(cached, id),
+          'ReactMount: Two valid but unequal nodes with the same `%s`: %s',
+          ATTR_NAME, id
+        );
+
+        nodeCache[id] = node;
+      }
+    } else {
+      nodeCache[id] = node;
+    }
+  }
+
+  return id;
+}
+
+function internalGetID(node) {
+  // If node is something like a window, document, or text node, none of
+  // which support attributes or a .getAttribute method, gracefully return
+  // the empty string, as if the attribute were missing.
+  return node && node.getAttribute && node.getAttribute(ATTR_NAME) || '';
+}
+
+/**
+ * Sets the React-specific ID of the given node.
+ *
+ * @param {DOMElement} node The DOM node whose ID will be set.
+ * @param {string} id The value of the ID attribute.
+ */
+function setID(node, id) {
+  var oldID = internalGetID(node);
+  if (oldID !== id) {
+    delete nodeCache[oldID];
+  }
+  node.setAttribute(ATTR_NAME, id);
+  nodeCache[id] = node;
+}
+
+/**
+ * Finds the node with the supplied React-generated DOM ID.
+ *
+ * @param {string} id A React-generated DOM ID.
+ * @return {DOMElement} DOM node with the suppled `id`.
+ * @internal
+ */
+function getNode(id) {
+  if (!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id], id)) {
+    nodeCache[id] = ReactMount.findReactNodeByID(id);
+  }
+  return nodeCache[id];
+}
+
+/**
+ * A node is "valid" if it is contained by a currently mounted container.
+ *
+ * This means that the node does not have to be contained by a document in
+ * order to be considered valid.
+ *
+ * @param {?DOMElement} node The candidate DOM node.
+ * @param {string} id The expected ID of the node.
+ * @return {boolean} Whether the node is contained by a mounted container.
+ */
+function isValid(node, id) {
+  if (node) {
+    invariant(
+      internalGetID(node) === id,
+      'ReactMount: Unexpected modification of `%s`',
+      ATTR_NAME
+    );
+
+    var container = ReactMount.findReactContainerForID(id);
+    if (container && contains(container, node)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function contains(ancestor, descendant) {
+  if (ancestor.contains) {
+    // Supported natively in virtually all browsers, but not in jsdom.
+    return ancestor.contains(descendant);
+  }
+
+  if (descendant === ancestor) {
+    return true;
+  }
+
+  if (descendant.nodeType === 3) {
+    // If descendant is a text node, start from descendant.parentNode
+    // instead, so that we can assume all ancestors worth considering are
+    // element nodes with nodeType === 1.
+    descendant = descendant.parentNode;
+  }
+
+  while (descendant && descendant.nodeType === 1) {
+    if (descendant === ancestor) {
+      return true;
+    }
+    descendant = descendant.parentNode;
+  }
+
+  return false;
+}
+
+/**
+ * Causes the cache to forget about one React-specific ID.
+ *
+ * @param {string} id The ID to forget.
+ */
+function purgeID(id) {
+  delete nodeCache[id];
 }
 
 /**
@@ -96,14 +223,10 @@ var ReactMount = {
    * Ensures that the top-level event delegation listener is set up. This will
    * be invoked some time before the first time any React component is rendered.
    *
-   * @param {object} TopLevelCallbackCreator
    * @private
    */
-  prepareTopLevelEvents: function(TopLevelCallbackCreator) {
-    ReactEventEmitter.ensureListening(
-      ReactMount.useTouchEvents,
-      TopLevelCallbackCreator
-    );
+  prepareTopLevelEvents: function() {
+    ReactEventEmitter.ensureListening(ReactMount.useTouchEvents);
   },
 
   /**
@@ -139,7 +262,7 @@ var ReactMount = {
    * @return {string} reactRoot ID prefix
    */
   _registerComponent: function(nextComponent, container) {
-    ReactMount.prepareTopLevelEvents(ReactEventTopLevelCallback);
+    ReactMount.prepareTopLevelEvents();
 
     var reactRootID = ReactMount.registerContainer(container);
     instanceByReactRootID[reactRootID] = nextComponent;
@@ -203,8 +326,7 @@ var ReactMount = {
 
     var reactRootElement = getReactRootElementInContainer(container);
     var containerHasReactMarkup =
-      reactRootElement &&
-        ReactInstanceHandles.isRenderedByReact(reactRootElement);
+      reactRootElement && ReactMount.isRenderedByReact(reactRootElement);
 
     var shouldReuseMarkup = containerHasReactMarkup && !registeredComponent;
 
@@ -302,15 +424,15 @@ var ReactMount = {
       var rootElement = rootElementsByReactRootID[reactRootID];
       if (rootElement && rootElement.parentNode !== container) {
         invariant(
-          // Call rawGetID here because getID calls isValid which calls
+          // Call internalGetID here because getID calls isValid which calls
           // findReactContainerForID (this function).
-          ReactID.rawGetID(rootElement) === reactRootID,
+          internalGetID(rootElement) === reactRootID,
           'ReactMount: Root element ID differed from reactRootID.'
         );
 
         var containerChild = container.firstChild;
         if (containerChild &&
-            reactRootID === ReactID.rawGetID(containerChild)) {
+            reactRootID === internalGetID(containerChild)) {
           // If the container has a new child with the same ID as the old
           // root element, then rootElementsByReactRootID[reactRootID] is
           // just stale and needs to be updated. The case that deserves a
@@ -336,9 +458,122 @@ var ReactMount = {
    */
   findReactNodeByID: function(id) {
     var reactRoot = ReactMount.findReactContainerForID(id);
-    return ReactInstanceHandles.findComponentRoot(reactRoot, id);
-  }
+    return ReactMount.findComponentRoot(reactRoot, id);
+  },
 
+  /**
+   * True if the supplied `node` is rendered by React.
+   *
+   * @param {*} node DOM Element to check.
+   * @return {boolean} True if the DOM Element appears to be rendered by React.
+   * @internal
+   */
+  isRenderedByReact: function(node) {
+    if (node.nodeType !== 1) {
+      // Not a DOMElement, therefore not a React component
+      return false;
+    }
+    var id = ReactMount.getID(node);
+    return id ? id.charAt(0) === SEPARATOR : false;
+  },
+
+  /**
+   * Traverses up the ancestors of the supplied node to find a node that is a
+   * DOM representation of a React component.
+   *
+   * @param {*} node
+   * @return {?DOMEventTarget}
+   * @internal
+   */
+  getFirstReactDOM: function(node) {
+    var current = node;
+    while (current && current.parentNode !== current) {
+      if (ReactMount.isRenderedByReact(current)) {
+        return current;
+      }
+      current = current.parentNode;
+    }
+    return null;
+  },
+
+  /**
+   * Finds a node with the supplied `id` inside of the supplied `ancestorNode`.
+   * Exploits the ID naming scheme to perform the search quickly.
+   *
+   * @param {DOMEventTarget} ancestorNode Search from this root.
+   * @pararm {string} id ID of the DOM representation of the component.
+   * @return {DOMEventTarget} DOM node with the supplied `id`.
+   * @internal
+   */
+  findComponentRoot: function(ancestorNode, id) {
+    var firstChildren = [ancestorNode.firstChild];
+    var childIndex = 0;
+
+    while (childIndex < firstChildren.length) {
+      var child = firstChildren[childIndex++];
+      while (child) {
+        var childID = ReactMount.getID(child);
+        if (childID) {
+          if (id === childID) {
+            return child;
+          } else if (ReactInstanceHandles.isAncestorIDOf(childID, id)) {
+            // If we find a child whose ID is an ancestor of the given ID,
+            // then we can be sure that we only want to search the subtree
+            // rooted at this child, so we can throw out the rest of the
+            // search state.
+            firstChildren.length = childIndex = 0;
+            firstChildren.push(child.firstChild);
+            break;
+          } else {
+            // TODO This should not be necessary if the ID hierarchy is
+            // correct, but is occasionally necessary if the DOM has been
+            // modified in unexpected ways.
+            firstChildren.push(child.firstChild);
+          }
+        } else {
+          // If this child had no ID, then there's a chance that it was
+          // injected automatically by the browser, as when a `<table>`
+          // element sprouts an extra `<tbody>` child as a side effect of
+          // `.innerHTML` parsing. Optimistically continue down this
+          // branch, but not before examining the other siblings.
+          firstChildren.push(child.firstChild);
+        }
+        child = child.nextSibling;
+      }
+    }
+
+    if (__DEV__) {
+      console.error(
+        'Error while invoking `findComponentRoot` with the following ' +
+        'ancestor node:',
+        ancestorNode
+      );
+    }
+    invariant(
+      false,
+      'findComponentRoot(..., %s): Unable to find element. This probably ' +
+      'means the DOM was unexpectedly mutated (e.g. by the browser).',
+      id,
+      ReactMount.getID(ancestorNode)
+    );
+  },
+
+
+  /**
+   * React ID utilities.
+   */
+
+  ATTR_NAME: ATTR_NAME,
+
+  getID: getID,
+
+  setID: setID,
+
+  getNode: getNode,
+
+  purgeID: purgeID,
+
+  injection: {}
 };
 
 module.exports = ReactMount;

src/core/ReactNativeComponent.js

@@ -25,7 +25,7 @@ var DOMPropertyOperations = require('DOMPropertyOperations');
 var ReactComponent = require('ReactComponent');
 var ReactEventEmitter = require('ReactEventEmitter');
 var ReactMultiChild = require('ReactMultiChild');
-var ReactID = require('ReactID');
+var ReactMount = require('ReactMount');
 
 var escapeTextForBrowser = require('escapeTextForBrowser');
 var flattenChildren = require('flattenChildren');
@@ -136,7 +136,7 @@ ReactNativeComponent.Mixin = {
     }
 
     var escapedID = escapeTextForBrowser(this._rootNodeID);
-    return ret + ' ' + ReactID.ATTR_NAME + '="' + escapedID + '">';
+    return ret + ' ' + ReactMount.ATTR_NAME + '="' + escapedID + '">';
   },
 
   /**

src/core/ReactTextComponent.js

@@ -20,7 +20,7 @@
 "use strict";
 
 var ReactComponent = require('ReactComponent');
-var ReactID = require('ReactID');
+var ReactMount = require('ReactMount');
 
 var escapeTextForBrowser = require('escapeTextForBrowser');
 var mixInto = require('mixInto');
@@ -58,7 +58,7 @@ mixInto(ReactTextComponent, {
   mountComponent: function(rootID) {
     ReactComponent.Mixin.mountComponent.call(this, rootID);
     return (
-      '<span ' + ReactID.ATTR_NAME + '="' + rootID + '">' +
+      '<span ' + ReactMount.ATTR_NAME + '="' + escapeTextForBrowser(rootID) + '">' +
         escapeTextForBrowser(this.props.text) +
       '</span>'
     );

src/core/ReactUpdates.js

@@ -54,7 +54,7 @@ function batchedUpdates(callback) {
         component.performUpdateIfNecessary();
         if (callbacks) {
           for (var j = 0; j < callbacks.length; j++) {
-            callbacks[j]();
+            callbacks[j].call(component);
           }
         }
       }

src/core/__tests__/ReactCompositeComponent-test.js

@@ -25,7 +25,7 @@ var React;
 var ReactCurrentOwner;
 var ReactPropTypes;
 var ReactTestUtils;
-var ReactID;
+var ReactMount;
 var ReactDoNotBindDeprecated;
 
 var cx;
@@ -41,7 +41,7 @@ describe('ReactCompositeComponent', function() {
     ReactDoNotBindDeprecated = require('ReactDoNotBindDeprecated');
     ReactPropTypes = require('ReactPropTypes');
     ReactTestUtils = require('ReactTestUtils');
-    ReactID = require('ReactID');
+    ReactMount = require('ReactMount');
 
     MorphingComponent = React.createClass({
       getInitialState: function() {
@@ -129,11 +129,13 @@ describe('ReactCompositeComponent', function() {
     // rerender
     instance.setProps({renderAnchor: true, anchorClassOn: false});
     var anchorID = instance.getAnchorID();
-    var actualDOMAnchorNode = ReactID.getNode(anchorID);
+    var actualDOMAnchorNode = ReactMount.getNode(anchorID);
     expect(actualDOMAnchorNode.className).toBe('');
   });
 
   it('should auto bind methods and values correctly', function() {
+    spyOn(console, 'warn');
+
     var ComponentClass = React.createClass({
       getInitialState: function() {
         return {valueToReturn: 'hi'};
@@ -168,7 +170,9 @@ describe('ReactCompositeComponent', function() {
     // Next, prove that once mounted, the scope is bound correctly to the actual
     // component.
     ReactTestUtils.renderIntoDocument(instance);
+    expect(console.warn.argsForCall.length).toBe(0);
     var explicitlyBound = instance.methodToBeExplicitlyBound.bind(instance);
+    expect(console.warn.argsForCall.length).toBe(1);
     var autoBound = instance.methodAutoBound;
     var explicitlyNotBound = instance.methodExplicitlyNotBound;
 

src/core/__tests__/ReactDOM-test.js

@@ -25,7 +25,7 @@ var React = require('React');
 var ReactDOM = require('ReactDOM');
 var ReactTestUtils = require('ReactTestUtils');
 var React = require('React');
-var ReactID = require('ReactID');
+var ReactMount = require('ReactMount');
 
 describe('ref swapping', function() {
   // TODO: uncomment this test once we can run in phantom, which
@@ -61,7 +61,7 @@ describe('ref swapping', function() {
     var argDiv = ReactTestUtils.renderIntoDocument(
       ReactDOM.div(null, 'child')
     );
-    var argNode = ReactID.getNode(argDiv._rootNodeID);
+    var argNode = ReactMount.getNode(argDiv._rootNodeID);
     expect(argNode.innerHTML).toBe('child');
   });
 
@@ -69,7 +69,7 @@ describe('ref swapping', function() {
     var conflictDiv = ReactTestUtils.renderIntoDocument(
       ReactDOM.div({children: 'fakechild'}, 'child')
     );
-    var conflictNode = ReactID.getNode(conflictDiv._rootNodeID);
+    var conflictNode = ReactMount.getNode(conflictDiv._rootNodeID);
     expect(conflictNode.innerHTML).toBe('child');
   });
 
@@ -111,7 +111,7 @@ describe('ref swapping', function() {
         theBird: <div class="bird" />
       }
     });
-    var root = ReactID.getNode(myDiv._rootNodeID);
+    var root = ReactMount.getNode(myDiv._rootNodeID);
     var dog = root.childNodes[0];
     expect(dog.className).toBe('bigdog');
   });

src/core/__tests__/ReactDOMIDOperations-test.js

@@ -23,11 +23,11 @@
 describe('ReactDOMIDOperations', function() {
   var DOMPropertyOperations = require('DOMPropertyOperations');
   var ReactDOMIDOperations = require('ReactDOMIDOperations');
-  var ReactID = require('ReactID');
+  var ReactMount = require('ReactMount');
   var keyOf = require('keyOf');
 
   it('should disallow updating special properties', function() {
-    spyOn(ReactID, "getNode");
+    spyOn(ReactMount, "getNode");
     spyOn(DOMPropertyOperations, "setValueForProperty");
 
     expect(function() {
@@ -39,7 +39,7 @@ describe('ReactDOMIDOperations', function() {
     }).toThrow();
 
     expect(
-      ReactID.getNode.argsForCall[0][0]
+      ReactMount.getNode.argsForCall[0][0]
     ).toBe('testID');
 
     expect(
@@ -49,7 +49,7 @@ describe('ReactDOMIDOperations', function() {
 
   it('should update innerHTML and special-case whitespace', function() {
     var stubNode = document.createElement('div');
-    spyOn(ReactID, "getNode").andReturn(stubNode);
+    spyOn(ReactMount, "getNode").andReturn(stubNode);
 
     ReactDOMIDOperations.updateInnerHTMLByID(
       'testID',
@@ -57,7 +57,7 @@ describe('ReactDOMIDOperations', function() {
     );
 
     expect(
-      ReactID.getNode.argsForCall[0][0]
+      ReactMount.getNode.argsForCall[0][0]
     ).toBe('testID');
 
     expect(stubNode.innerHTML).toBe(' testContent');

src/core/__tests__/ReactEventEmitter-test.js

@@ -22,7 +22,7 @@ require('mock-modules')
     .dontMock('BrowserScroll')
     .dontMock('CallbackRegistry')
     .dontMock('EventPluginHub')
-    .dontMock('ReactID')
+    .dontMock('ReactMount')
     .dontMock('ReactEventEmitter')
     .dontMock('ReactInstanceHandles')
     .dontMock('EventPluginHub')
@@ -35,11 +35,10 @@ var keyOf = require('keyOf');
 var mocks = require('mocks');
 
 var EventPluginHub;
-var ReactID = require('ReactID');
-var getID = ReactID.getID;
-var setID = ReactID.setID;
+var ReactMount = require('ReactMount');
+var getID = ReactMount.getID;
+var setID = ReactMount.setID;
 var ReactEventEmitter;
-var ReactEventTopLevelCallback;
 var ReactTestUtils;
 var TapEventPlugin;
 
@@ -89,15 +88,14 @@ describe('ReactEventEmitter', function() {
     require('mock-modules').dumpCache();
     EventPluginHub = require('EventPluginHub');
     TapEventPlugin = require('TapEventPlugin');
-    ReactID = require('ReactID');
-    getID = ReactID.getID;
-    setID = ReactID.setID;
+    ReactMount = require('ReactMount');
+    getID = ReactMount.getID;
+    setID = ReactMount.setID;
     ReactEventEmitter = require('ReactEventEmitter');
     ReactTestUtils = require('ReactTestUtils');
-    ReactEventTopLevelCallback = require('ReactEventTopLevelCallback');
     idCallOrder = [];
     tapMoveThreshold = TapEventPlugin.tapMoveThreshold;
-    ReactEventEmitter.ensureListening(false, ReactEventTopLevelCallback);
+    ReactEventEmitter.ensureListening(false);
     EventPluginHub.injection.injectEventPluginsByName({
       TapEventPlugin: TapEventPlugin
     });

src/core/__tests__/ReactIdentity-test.js

@@ -22,7 +22,7 @@
 var React;
 var ReactTestUtils;
 var reactComponentExpect;
-var ReactID;
+var ReactMount;
 
 describe('ReactIdentity', function() {
 
@@ -31,12 +31,12 @@ describe('ReactIdentity', function() {
     React = require('React');
     ReactTestUtils = require('ReactTestUtils');
     reactComponentExpect = require('reactComponentExpect');
-    ReactID = require('ReactID');
+    ReactMount = require('ReactMount');
   });
 
   var idExp = /^\.r\[.+?\](.*)$/;
   function checkId(child, expectedId) {
-    var actual = idExp.exec(ReactID.getID(child));
+    var actual = idExp.exec(ReactMount.getID(child));
     var expected = idExp.exec(expectedId);
     expect(actual).toBeTruthy();
     expect(expected).toBeTruthy();
@@ -281,11 +281,11 @@ describe('ReactIdentity', function() {
 
     React.renderComponent(wrapped, document.createElement('div'));
 
-    var beforeID = ReactID.getID(wrapped.getDOMNode().firstChild);
+    var beforeID = ReactMount.getID(wrapped.getDOMNode().firstChild);
 
     wrapped.swap();
 
-    var afterID = ReactID.getID(wrapped.getDOMNode().firstChild);
+    var afterID = ReactMount.getID(wrapped.getDOMNode().firstChild);
 
     expect(beforeID).not.toEqual(afterID);
 

src/core/__tests__/ReactInstanceHandles-test.js

@@ -21,7 +21,7 @@
 
 var React = require('React');
 var ReactTestUtils = require('ReactTestUtils');
-var ReactID = require('ReactID');
+var ReactMount = require('ReactMount');
 
 /**
  * Ensure that all callbacks are invoked, passing this unique argument.
@@ -78,7 +78,7 @@ describe('ReactInstanceHandles', function() {
   describe('isRenderedByReact', function() {
     it('should not crash on text nodes', function() {
       expect(function() {
-        ReactInstanceHandles.isRenderedByReact(document.createTextNode('yolo'));
+        ReactMount.isRenderedByReact(document.createTextNode('yolo'));
       }).not.toThrow();
     });
   });
@@ -91,14 +91,14 @@ describe('ReactInstanceHandles', function() {
       parentNode.appendChild(childNodeA);
       parentNode.appendChild(childNodeB);
 
-      ReactID.setID(parentNode, '.react[0]');
-      ReactID.setID(childNodeA, '.react[0].0');
-      ReactID.setID(childNodeB, '.react[0].0:1');
+      ReactMount.setID(parentNode, '.react[0]');
+      ReactMount.setID(childNodeA, '.react[0].0');
+      ReactMount.setID(childNodeB, '.react[0].0:1');
 
       expect(
-        ReactInstanceHandles.findComponentRoot(
+        ReactMount.findComponentRoot(
           parentNode,
-          ReactID.getID(childNodeB)
+          ReactMount.getID(childNodeB)
         )
       ).toBe(childNodeB);
     });
@@ -110,14 +110,14 @@ describe('ReactInstanceHandles', function() {
       parentNode.appendChild(childNodeA);
       parentNode.appendChild(childNodeB);
 
-      ReactID.setID(parentNode, '.react[0]');
+      ReactMount.setID(parentNode, '.react[0]');
       // No ID on `childNodeA`.
-      ReactID.setID(childNodeB, '.react[0].0:1');
+      ReactMount.setID(childNodeB, '.react[0].0:1');
 
       expect(
-        ReactInstanceHandles.findComponentRoot(
+        ReactMount.findComponentRoot(
           parentNode,
-          ReactID.getID(childNodeB)
+          ReactMount.getID(childNodeB)
         )
       ).toBe(childNodeB);
     });
@@ -129,25 +129,30 @@ describe('ReactInstanceHandles', function() {
       parentNode.appendChild(childNodeA);
       childNodeA.appendChild(childNodeB);
 
-      ReactID.setID(parentNode, '.react[0]');
+      ReactMount.setID(parentNode, '.react[0]');
       // No ID on `childNodeA`, it was "rendered by the browser".
-      ReactID.setID(childNodeB, '.react[0].1:0');
+      ReactMount.setID(childNodeB, '.react[0].1:0');
 
-      expect(ReactInstanceHandles.findComponentRoot(
+      expect(ReactMount.findComponentRoot(
         parentNode,
-        ReactID.getID(childNodeB)
+        ReactMount.getID(childNodeB)
       )).toBe(childNodeB);
 
+      spyOn(console, 'error');
+      expect(console.error.argsForCall.length).toBe(0);
+
       expect(function() {
-        ReactInstanceHandles.findComponentRoot(
+        ReactMount.findComponentRoot(
           parentNode,
-          ReactID.getID(childNodeB) + ":junk"
+          ReactMount.getID(childNodeB) + ":junk"
         );
       }).toThrow(
         'Invariant Violation: findComponentRoot(..., .react[0].1:0:junk): ' +
         'Unable to find element. This probably means the DOM was ' +
         'unexpectedly mutated (e.g. by the browser).'
       );
+
+      expect(console.error.argsForCall.length).toBe(1);
     });
   });
 

src/core/__tests__/ReactMultiChildReconcile-test.js

@@ -23,7 +23,7 @@ require('mock-modules');
 
 var React = require('React');
 var ReactTestUtils = require('ReactTestUtils');
-var ReactID = require('ReactID');
+var ReactMount = require('ReactMount');
 
 var objMapKeyVal = require('objMapKeyVal');
 
@@ -191,7 +191,7 @@ function verifyDomOrderingAccurate(parentInstance, statusDisplays) {
   var i;
   var orderedDomIds = [];
   for (i=0; i < statusDisplayNodes.length; i++) {
-    orderedDomIds.push(ReactID.getID(statusDisplayNodes[i]));
+    orderedDomIds.push(ReactMount.getID(statusDisplayNodes[i]));
   }
 
   var orderedLogicalIds = [];

src/core/__tests__/ReactNativeComponent-test.js

@@ -317,7 +317,7 @@ describe('ReactNativeComponent', function() {
     it("should clean up listeners", function() {
       var React = require('React');
       var ReactEventEmitter = require('ReactEventEmitter');
-      var ReactID = require('ReactID');
+      var ReactMount = require('ReactMount');
 
       var container = document.createElement('div');
       document.documentElement.appendChild(container);
@@ -327,7 +327,7 @@ describe('ReactNativeComponent', function() {
       React.renderComponent(instance, container);
 
       var rootNode = instance.getDOMNode();
-      var rootNodeID = ReactID.getID(rootNode);
+      var rootNodeID = ReactMount.getID(rootNode);
       expect(
         ReactEventEmitter.getListener(rootNodeID, 'onClick')
       ).toBe(callback);

src/core/__tests__/ReactUpdates-test.js

@@ -237,6 +237,7 @@ describe('ReactUpdates', function() {
     ReactUpdates.batchedUpdates(function() {
       instance.setState({x: 1}, function() {
         instance.setState({x: 2}, function() {
+          expect(this).toBe(instance);
           innerCallbackRun = true;
           expect(instance.state.x).toBe(2);
           expect(updateCount).toBe(2);

src/core/__tests__/refs-test.js

@@ -44,7 +44,11 @@ var ClickCounter = React.createClass({
     var i;
     for (i=0; i < this.state.count; i++) {
       children.push(
-        <div className="clickLogDiv" ref={"clickLog" + i} />
+        <div
+          className="clickLogDiv"
+          key={"clickLog" + i}
+          ref={"clickLog" + i}
+        />
       );
     }
     return (

src/core/getReactRootElementInContainer.js

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @providesModule getReactRootElementInContainer
+ */
+
+"use strict";
+
+/**
+ * @param {DOMElement} container DOM element that may contain a React component
+ * @return {?*} DOM element that may have the reactRoot ID, or null.
+ */
+function getReactRootElementInContainer(container) {
+  return container && container.firstChild;
+}
+
+module.exports = getReactRootElementInContainer;

src/dom/DefaultDOMPropertyConfig.js

@@ -38,6 +38,7 @@ var DefaultDOMPropertyConfig = {
     action: null,
     ajaxify: MUST_USE_ATTRIBUTE,
     allowFullScreen: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
+    allowTransparency: MUST_USE_ATTRIBUTE,
     alt: null,
     autoComplete: null,
     autoFocus: HAS_BOOLEAN_VALUE,
@@ -56,6 +57,7 @@ var DefaultDOMPropertyConfig = {
     disabled: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
     draggable: null,
     encType: null,
+    frameBorder: MUST_USE_ATTRIBUTE,
     height: MUST_USE_ATTRIBUTE,
     hidden: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
     href: null,

src/dom/components/__tests__/ReactDOMTextarea-test.js

@@ -62,9 +62,12 @@ describe('ReactDOMTextarea', function() {
   });
 
   it('should treat children like `defaultValue`', function() {
+    spyOn(console, 'warn');
+
     var stub = <textarea>giraffe</textarea>;
     var node = renderTextarea(stub);
 
+    expect(console.warn.argsForCall.length).toBe(1);
     expect(node.value).toBe('giraffe');
 
     // Changing children should do nothing, it functions like `defaultValue`.
@@ -73,21 +76,29 @@ describe('ReactDOMTextarea', function() {
   });
 
   it('should allow numbers as children', function() {
+    spyOn(console, 'warn');
     var node = renderTextarea(<textarea>{17}</textarea>);
+    expect(console.warn.argsForCall.length).toBe(1);
     expect(node.value).toBe('17');
   });
 
   it("should throw with multiple or invalid children", function() {
+    spyOn(console, 'warn');
+
     expect(function() {
       ReactTestUtils.renderIntoDocument(
         <textarea>{'hello'}{'there'}</textarea>
       );
     }).toThrow();
 
+    expect(console.warn.argsForCall.length).toBe(1);
+
     expect(function() {
       ReactTestUtils.renderIntoDocument(
         <textarea><strong /></textarea>
       );
     }).toThrow();
+
+    expect(console.warn.argsForCall.length).toBe(2);
   });
 });

src/environment/ReactMarkupChecksum.js

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @providesModule ReactMarkupChecksum
+ */
+
+"use strict";
+
+var adler32 = require('adler32');
+
+var ReactMarkupChecksum = {
+  CHECKSUM_ATTR_NAME: 'data-react-checksum',
+
+  /**
+   * @param {string} markup Markup string
+   * @return {string} Markup string with checksum attribute attached
+   */
+  addChecksumToMarkup: function(markup) {
+    var checksum = adler32(markup);
+    return markup.replace(
+      '>',
+      ' ' + ReactMarkupChecksum.CHECKSUM_ATTR_NAME + '="' + checksum + '">'
+    );
+  },
+
+  /**
+   * @param {string} markup to use
+   * @param {DOMElement} element root React element
+   * @returns {boolean} whether or not the markup is the same
+   */
+  canReuseMarkup: function(markup, element) {
+    var existingChecksum = element.getAttribute(
+      ReactMarkupChecksum.CHECKSUM_ATTR_NAME
+    );
+    existingChecksum = existingChecksum && parseInt(existingChecksum, 10);
+    var markupChecksum = adler32(markup);
+    return markupChecksum === existingChecksum;
+  }
+};
+
+module.exports = ReactMarkupChecksum;

src/environment/ReactServerRendering.js

@@ -18,6 +18,7 @@
  */
 "use strict";
 
+var ReactMarkupChecksum = require('ReactMarkupChecksum');
 var ReactReconcileTransaction = require('ReactReconcileTransaction');
 var ReactInstanceHandles = require('ReactInstanceHandles');
 
@@ -33,7 +34,9 @@ function renderComponentToString(component, callback) {
   transaction.reinitializeTransaction();
   try {
     transaction.perform(function() {
-      callback(component.mountComponent(id, transaction));
+      var markup = component.mountComponent(id, transaction);
+      markup = ReactMarkupChecksum.addChecksumToMarkup(markup);
+      callback(markup);
     }, null);
   } finally {
     ReactReconcileTransaction.release(transaction);

src/environment/__tests__/ReactServerRendering-test.js

@@ -24,25 +24,30 @@
 require('mock-modules')
   .dontMock('ExecutionEnvironment')
   .dontMock('React')
-  .dontMock('ReactID')
+  .dontMock('ReactMount')
   .dontMock('ReactServerRendering')
-  .dontMock('ReactTestUtils');
+  .dontMock('ReactTestUtils')
+  .dontMock('ReactMarkupChecksum');
+
+var mocks = require('mocks');
 
 var React;
-var ReactID;
+var ReactMount;
 var ReactTestUtils;
 var ReactServerRendering;
+var ReactMarkupChecksum;
 var ExecutionEnvironment;
 
 describe('ReactServerRendering', function() {
   beforeEach(function() {
     require('mock-modules').dumpCache();
     React = require('React');
-    ReactID = require('ReactID');
+    ReactMount = require('ReactMount');
     ReactTestUtils = require('ReactTestUtils');
     ExecutionEnvironment = require('ExecutionEnvironment');
     ExecutionEnvironment.canUseDOM = false;
     ReactServerRendering = require('ReactServerRendering');
+    ReactMarkupChecksum = require('ReactMarkupChecksum');
   });
 
   it('should generate simple markup', function() {
@@ -54,7 +59,8 @@ describe('ReactServerRendering', function() {
       }
     );
     expect(response).toMatch(
-      '<span ' + ReactID.ATTR_NAME + '="[^"]+">hello world</span>'
+      '<span ' + ReactMount.ATTR_NAME + '="[^"]+" ' +
+        ReactMarkupChecksum.CHECKSUM_ATTR_NAME + '="[^"]+">hello world</span>'
     );
   });
 
@@ -77,10 +83,11 @@ describe('ReactServerRendering', function() {
       }
     );
     expect(response).toMatch(
-      '<div ' + ReactID.ATTR_NAME + '="[^"]+">' +
-        '<span ' + ReactID.ATTR_NAME + '="[^"]+">' +
-          '<span ' + ReactID.ATTR_NAME + '="[^"]+">My name is </span>' +
-          '<span ' + ReactID.ATTR_NAME + '="[^"]+">child</span>' +
+      '<div ' + ReactMount.ATTR_NAME + '="[^"]+" ' +
+        ReactMarkupChecksum.CHECKSUM_ATTR_NAME + '="[^"]+">' +
+        '<span ' + ReactMount.ATTR_NAME + '="[^"]+">' +
+          '<span ' + ReactMount.ATTR_NAME + '="[^"]+">My name is </span>' +
+          '<span ' + ReactMount.ATTR_NAME + '="[^"]+">child</span>' +
         '</span>' +
       '</div>'
     );
@@ -130,9 +137,10 @@ describe('ReactServerRendering', function() {
     );
 
     expect(response).toMatch(
-      '<span ' + ReactID.ATTR_NAME + '="[^"]+">' +
-        '<span ' + ReactID.ATTR_NAME + '="[^"]+">Component name: </span>' +
-        '<span ' + ReactID.ATTR_NAME + '="[^"]+">TestComponent</span>' +
+      '<span ' + ReactMount.ATTR_NAME + '="[^"]+" ' +
+        ReactMarkupChecksum.CHECKSUM_ATTR_NAME + '="[^"]+">' +
+        '<span ' + ReactMount.ATTR_NAME + '="[^"]+">Component name: </span>' +
+        '<span ' + ReactMount.ATTR_NAME + '="[^"]+">TestComponent</span>' +
       '</span>'
     );
     expect(lifecycle).toEqual(
@@ -148,7 +156,7 @@ describe('ReactServerRendering', function() {
     var numClicks = 0;
 
     var TestComponent = React.createClass({
-      componentWillMount: function() {
+      componentDidMount: function() {
         mountCount++;
       },
       click: function() {
@@ -179,18 +187,41 @@ describe('ReactServerRendering', function() {
     expect(mountCount).toEqual(2);
     expect(element.innerHTML).not.toEqual(lastMarkup);
 
-    // Now kill the node and render it on top of the old markup, as if
+    // Now kill the node and render it on top of server-rendered markup, as if
     // we used server rendering. We should mount again, but the markup should be
-    // unchanged.
-    lastMarkup = element.innerHTML;
+    // unchanged. We will append a sentinel at the end of innerHTML to be sure
+    // that innerHTML was not changed.
     React.unmountAndReleaseReactRootNode(element);
     expect(element.innerHTML).toEqual('');
-    element.innerHTML = lastMarkup;
-    // NOTE: we pass a different name here. This is to ensure that the markup
-    // being generated is not replaced.
-    var instance = React.renderComponent(<TestComponent name="y" />, element);
+
+    ExecutionEnvironment.canUseDOM = false;
+    ReactServerRendering.renderComponentToString(
+      <TestComponent name="x" />,
+      function(markup) {
+        lastMarkup = markup;
+      }
+    );
+    ExecutionEnvironment.canUseDOM = true;
+
+    element.innerHTML = lastMarkup + ' __sentinel__';
+
+    React.renderComponent(<TestComponent name="x" />, element);
     expect(mountCount).toEqual(3);
-    expect(element.innerHTML).toEqual(lastMarkup);
+    expect(element.innerHTML.indexOf('__sentinel__') > -1).toBe(true);
+    React.unmountAndReleaseReactRootNode(element);
+    expect(element.innerHTML).toEqual('');
+
+    // Now simulate a situation where the app is not idempotent. React should
+    // warn but do the right thing.
+    var _warn = console.warn;
+    console.warn = mocks.getMockFunction();
+    element.innerHTML = lastMarkup;
+    var instance = React.renderComponent(<TestComponent name="y" />, element);
+    expect(mountCount).toEqual(4);
+    expect(console.warn.mock.calls.length).toBe(1);
+    expect(element.innerHTML.length > 0).toBe(true);
+    expect(element.innerHTML).not.toEqual(lastMarkup);
+    console.warn = _warn;
 
     // Ensure the events system works
     expect(numClicks).toEqual(0);

src/event/synthetic/SyntheticEvent.js

@@ -68,6 +68,9 @@ function SyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent) {
 
   var Interface = this.constructor.Interface;
   for (var propName in Interface) {
+    if (!Interface.hasOwnProperty(propName)) {
+      continue;
+    }
     var normalize = Interface[propName];
     if (normalize) {
       this[propName] = normalize(nativeEvent);