react-rails-stupid 1.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a9438b66a924541d0d5cd30245eecf8e8485be39e8ce11481347cefdb67c8db1
+  data.tar.gz: c30a7dfb638a2cc96c360bd00494fb0c12d8269c889ba907b717f7fb26089071
+SHA512:
+  metadata.gz: 509dab980a0931502243251a96f4230b192822254c612a38caef85da3df1971e029f7d68dbd2dd15e22feb9edb1a66f2c4f11b9cb3632f4074e9146f59c21cc8
+  data.tar.gz: 27515b984ff1944d42042b80f50eb6836e7b5aba18925a64773b9fb923829f57e5a0e42c3faadf729fc9bc3a49eeb510477a407a0b49e92c01e48c35eb358729

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

data/README.md

@@ -0,0 +1,423 @@
+# react-rails-stupid
+
+the call
+`react_component 'Button', text: 'click me'`
+
+ensures some html: `<div data-react-class="Button" data-react-props="{...}"/>`
+
+next, you can use separeted frontend with a helper
+
+<details><summary>the helper</summary>
+  
+```js
+function get(obj, path){ return path.split('.').reduce((obj, key) => obj[key], obj) }
+
+[...document.querySelectorAll('[data-react-class]')].forEach((root) => {
+	ReactDOM.render(
+		React.createElement(
+			get(window, root.dataset.reactClass),
+			JSON.parse(root.dataset.reactProps)
+		),
+		root
+	)
+})
+```
+
+</details>
+
+`window.Button` expected
+
+also, you can use nested objects as a react components like `User.Title`
+
+usage:
+
+js: `window.User = { Title };`
+
+rb: `react_component 'User.Title', name: 'Evan Smith'`
+
+
+<br/><br/><br/><br/>
+
+
+
+# Original readme
+
+`react-rails` makes it easy to use [React](http://facebook.github.io/react/) and [JSX](http://facebook.github.io/react/docs/jsx-in-depth.html)
+in your Ruby on Rails (3.2+) application. `react-rails` can:
+
+- Provide [various `react` builds](#reactjs-builds) to your asset bundle
+- Transform [`.jsx` in the asset pipeline](#jsx)
+- [Render components into views and mount them](#rendering--mounting) via view helper & `react_ujs`
+- [Render components server-side](#server-rendering) with `prerender: true`
+- [Generate components](#component-generator) with a Rails generator
+- [Be extended](#extending-react-rails) with custom renderers, transformers and view helpers
+
+Just getting started with React? Make sure to check out the [Getting Started] (https://facebook.github.io/react/docs/getting-started.html) guide.
+
+## Installation
+
+Add `react-rails` to your gemfile:
+
+```ruby
+gem 'react-rails', '~> 1.5.0'
+```
+
+Next, run the installation script:
+
+```bash
+rails g react:install
+```
+
+This will:
+- create a `components.js` manifest file and a `app/assets/javascripts/components/` directory,
+where you will put your components
+- place the following in your `application.js`:
+
+  ```js
+  //= require react
+  //= require react_ujs
+  //= require components
+  ```
+
+## Usage
+
+### React.js builds
+
+You can pick which React.js build (development, production, with or without [add-ons]((http://facebook.github.io/react/docs/addons.html)))
+to serve in each environment by adding a config. Here are the defaults:
+
+```ruby
+# config/environments/development.rb
+MyApp::Application.configure do
+  config.react.variant = :development
+end
+
+# config/environments/production.rb
+MyApp::Application.configure do
+  config.react.variant = :production
+end
+```
+
+To include add-ons, use this config:
+
+```ruby
+MyApp::Application.configure do
+  config.react.addons = true # defaults to false
+end
+```
+
+After restarting your Rails server, `//= require react`  will provide the build of React.js which
+was specified by the configurations.
+
+`react-rails` offers a few other options for versions & builds of React.js.
+See [VERSIONS.md](https://github.com/reactjs/react-rails/blob/master/VERSIONS.md) for more info about
+ using the `react-source` gem or dropping in your own copies of React.js.
+
+### JSX
+
+After installing `react-rails`, restart your server. Now, `.js.jsx` files will be transformed in the asset pipeline.
+
+`react-rails` currently ships with two transformers, to convert jsx code -
+
+* `BabelTransformer` using [Babel](http://babeljs.io), which is the default transformer.
+* `JSXTransformer` using `JSXTransformer.js`
+
+You can use the deprecated `JSXTransformer` by setting it in an application config:
+
+```ruby
+  config.react.jsx_transformer_class = React::JSX::JSXTransformer
+```
+
+#### BabelTransformer options
+
+You can use babel's [transformers](http://babeljs.io/docs/advanced/transformers/) and [custom plugins](http://babeljs.io/docs/advanced/plugins/),
+and pass [options](http://babeljs.io/docs/usage/options/) to the babel transpiler adding following configurations:
+
+```ruby
+config.react.jsx_transform_options = {
+  blacklist: ['spec.functionName', 'validation.react', 'strict'], # default options
+  optional: ["transformerName"],  # pass extra babel options
+  whitelist: ["useStrict"] # even more options
+}
+```
+Under the hood, `react-rails` uses [ruby-babel-transpiler](https://github.com/babel/ruby-babel-transpiler), for transformation.
+
+#### JSXTransformer options
+
+You can use JSX `--harmony` or `--strip-types` options by adding a configuration:
+
+```ruby
+config.react.jsx_transform_options = {
+  harmony: true,
+  strip_types: true, # for removing Flow type annotations
+  asset_path: "path/to/JSXTransformer.js", # if your JSXTransformer is somewhere else
+}
+```
+
+### Rendering & mounting
+
+`react-rails` includes a view helper (`react_component`) and an unobtrusive JavaScript driver (`react_ujs`)
+which work together to put React components on the page. You should require the UJS driver
+ in your manifest after `react` (and after `turbolinks` if you use [Turbolinks](https://github.com/rails/turbolinks)).
+
+The __view helper__ puts a `div` on the page with the requested component class & props. For example:
+
+```erb
+<%= react_component('HelloMessage', name: 'John') %>
+<!-- becomes: -->
+<div data-react-class="HelloMessage" data-react-props="{&quot;name&quot;:&quot;John&quot;}"></div>
+```
+
+On page load, the __`react_ujs` driver__ will scan the page and mount components using `data-react-class`
+and `data-react-props`.
+
+If Turbolinks is present components are mounted on the `page:change` event, and unmounted on `page:before-unload`.
+ __Turbolinks >= 2.4.0__ is recommended because it exposes better events.
+
+The view helper's signature is:
+
+```ruby
+react_component(component_class_name, props={}, html_options={})
+```
+
+- `component_class_name` is a string which names a globally-accessible component class. It may have dots (eg, `"MyApp.Header.MenuItem"`).
+- `props` is either an object that responds to `#to_json` or an already-stringified JSON object (eg, made with Jbuilder, see note below).
+- `html_options` may include:
+  - `tag:` to use an element other than a `div` to embed `data-react-class` and `-props`.
+  - `prerender: true` to render the component on the server.
+  - `**other` Any other arguments (eg `class:`, `id:`) are passed through to [`content_tag`](http://api.rubyonrails.org/classes/ActionView/Helpers/TagHelper.html#method-i-content_tag).
+
+
+### Server rendering
+
+To render components on the server, pass `prerender: true` to `react_component`:
+
+```erb
+<%= react_component('HelloMessage', {name: 'John'}, {prerender: true}) %>
+<!-- becomes: -->
+<div data-react-class="HelloMessage" data-react-props="{&quot;name&quot;:&quot;John&quot;}">
+  <h1>Hello, John!</h1>
+</div>
+```
+
+_(It will be also be mounted by the UJS on page load.)_
+
+There are some requirements for this to work:
+
+- `react-rails` must load your code. By convention it uses `components.js`, which was created
+by the install task. This file must include your components _and_ their dependencies (eg, Underscore.js).
+- Your components must be accessible in the global scope.
+If you are using `.js.jsx.coffee` files then the wrapper function needs to be taken into account:
+
+  ```coffee
+  # @ is `window`:
+  @Component = React.createClass
+    render: ->
+      `<ExampleComponent videos={this.props.videos} />`
+  ```
+- Your code can't reference `document`. Prerender processes don't have access to `document`,
+so jQuery and some other libs won't work in this environment :(
+
+You can configure your pool of JS virtual machines and specify where it should load code:
+
+```ruby
+# config/environments/application.rb
+# These are the defaults if you dont specify any yourself
+MyApp::Application.configure do
+  # Settings for the pool of renderers:
+  config.react.server_renderer_pool_size  ||= 1  # ExecJS doesn't allow more than one on MRI
+  config.react.server_renderer_timeout    ||= 20 # seconds
+  config.react.server_renderer = React::ServerRendering::SprocketsRenderer
+  config.react.server_renderer_options = {
+    files: ["react-server.js", "components.js"], # files to load for prerendering
+    replay_console: true,                 # if true, console.* will be replayed client-side
+  }
+end
+```
+
+- On MRI, use `therubyracer` for the best performance (see [discussion](https://github.com/reactjs/react-rails/pull/290))
+- On MRI, you'll get a deadlock with `pool_size` > 1
+- If you're using JRuby, you can increase `pool_size` to have real multi-threaded rendering.
+
+You can configure camelize_props option and pass props with an underscored hash from rails but get a camelized hash in jsx :
+
+```ruby
+MyApp::Application.configure do
+  config.react.camelize_props = true #default false
+end
+```
+
+### Rendering components instead of views
+
+Components can also be prerendered directly from a controller action with the custom `component` renderer. For example:
+
+```ruby
+class TodoController < ApplicationController
+  def index
+    @todos = Todo.all
+    render component: 'TodoList', props: { todos: @todos }, tag: 'span', class: 'todo'
+  end
+end
+```
+
+This custom renderer behaves the same as a normal view renderer and accepts the usual arguments - `content_type`, `layout`, `location` and `status`.
+By default, your current layout will be used and the component, rather than a view, will be rendered in place of `yield`. Custom data-* attributes
+can be passed like `data: {remote: true}`.
+
+### Component generator
+
+`react-rails` ships with a Rails generator to help you get started with a simple component scaffold.
+You can run it using `rails generate react:component ComponentName (--es6)`.
+The generator takes an optional list of arguments for default propTypes,
+which follow the conventions set in the [Reusable Components](http://facebook.github.io/react/docs/reusable-components.html)
+section of the React documentation.
+
+For example:
+
+```shell
+rails generate react:component Post title:string body:string published:bool published_by:instanceOf{Person}
+```
+
+would generate the following in `app/assets/javascripts/components/post.js.jsx`:
+
+```jsx
+var Post = React.createClass({
+  propTypes: {
+    title: React.PropTypes.string,
+    body: React.PropTypes.string,
+    published: React.PropTypes.bool,
+    publishedBy: React.PropTypes.instanceOf(Person)
+  },
+
+  render: function() {
+    return (
+      <div>
+        <div>Title: {this.props.title}</div>
+        <div>Body: {this.props.body}</div>
+        <div>Published: {this.props.published}</div>
+        <div>Published By: {this.props.publishedBy}</div>
+      </div>
+    );
+  }
+});
+```
+
+#### Options
+
+**--es6** : Generate the same component but using cutting edge es6 class
+
+For example:
+
+```shell
+rails generate react:component Label label:string --es6
+```
+
+**--coffee** : Generate the component using CoffeeScript syntax
+
+For example:
+
+```shell
+rails generate react:component Label label:string --coffee
+```
+
+#### Arguments
+
+The generator can use the following arguments to create basic propTypes:
+
+  * any
+  * array
+  * bool
+  * element
+  * func
+  * number
+  * object
+  * node
+  * shape
+  * string
+
+The following additional arguments have special behavior:
+
+  * `instanceOf` takes an optional class name in the form of {className}.
+  * `oneOf` behaves like an enum, and takes an optional list of strings in the form of `'name:oneOf{one,two,three}'`.
+  * `oneOfType` takes an optional list of react and custom types in the form of `'model:oneOfType{string,number,OtherType}'`.
+
+Note that the arguments for `oneOf` and `oneOfType` must be enclosed in single quotes
+ to prevent your terminal from expanding them into an argument list.
+
+### Jbuilder & react-rails
+
+If you use Jbuilder to pass a JSON string to `react_component`, make sure your JSON is a stringified hash,
+not an array. This is not the Rails default -- you should add the root node yourself. For example:
+
+```ruby
+# BAD: returns a stringified array
+json.array!(@messages) do |message|
+  json.extract! message, :id, :name
+  json.url message_url(message, format: :json)
+end
+
+# GOOD: returns a stringified hash
+json.messages(@messages) do |message|
+  json.extract! message, :id, :name
+  json.url message_url(message, format: :json)
+end
+```
+
+## CoffeeScript
+
+It is possible to use JSX with CoffeeScript. To use CoffeeScript, create files with an extension `.js.jsx.coffee`.
+We also need to embed JSX code inside backticks so that CoffeeScript ignores the syntax it doesn't understand.
+Here's an example:
+
+```coffee
+Component = React.createClass
+  render: ->
+    `<ExampleComponent videos={this.props.videos} />`
+```
+
+Alternatively, the newer ES6 style class based syntax can be used like this:
+
+```coffee
+class Component extends React.Component
+  render: ->
+    `<ExampleComponent videos={this.props.videos} />`
+```
+
+## Extending `react-rails`
+
+You can extend some of the core functionality of `react-rails` by injecting new implementations during configuration.
+
+### Custom Server Renderer
+
+`react-rails` depends on a renderer class for rendering components on the server. You can provide a custom renderer class to `config.react.server_renderer`. The class must implement:
+
+- `#initialize(options={})`, which accepts the hash from `config.react.server_renderer_options`
+- `#render(component_name, props, prerender_options)` to return a string of HTML
+
+`react-rails` provides two renderer classes: `React::ServerRendering::ExecJSRenderer` and `React::ServerRendering::SprocketsRenderer`.
+
+`ExecJSRenderer` offers two other points for extension:
+
+- `#before_render(component_name, props, prerender_options)` to return a string of JavaScript to execute _before_ calling `React.render`
+- `#after_render(component_name, props, prerender_options)` to return a string of JavaScript to execute _after_ calling `React.render`
+
+Any subclass of `ExecJSRenderer` may use those hooks (for example, `SprocketsRenderer` uses them to handle `console.*` on the server).
+
+### Custom View Helper
+
+`react-rails` uses a "helper implementation" class to generate the output of the `react_component` helper. The helper is initialized once per request and used for each `react_component` call during that request. You can provide a custom helper class to `config.react.view_helper_implementation`. The class must implement:
+
+- `#react_component(name, props = {}, options = {}, &block)` to return a string to inject into the Rails view
+- `#setup(controller_instance)`, called when the helper is initialized at the start of the request
+- `#teardown(controller_instance)`, called at the end of the request
+
+`react-rails` provides one implementation, `React::Rails::ComponentMount`.
+
+### Custom JSX Transformer
+
+`react-rails` uses a transformer class to transform JSX for the browser. The transformer is initialized once, at boot. You can provide a custom transformer to `config.react.jsx_transformer_class`. The transformer must implement:
+
+- `#initialize(options)`, where options is the value passed to `config.react.jsx_transform_options`
+- `#transform(code_string)` to return a string of transformed code
+
+`react-rails` provides two transformers, `React::JSX::JSXTransformer` and `React::JSX::BabelTransformer`.

data/lib/react/rails/component_mount.rb

@@ -0,0 +1,52 @@
+module React
+  module Rails
+    # This is the default view helper implementation.
+    # It just inserts HTML into the DOM (see {#react_component}).
+    #
+    # You can extend this class or provide your own implementation
+    # by assigning it to `config.react.view_helper_implementation`.
+    class ComponentMount
+      include ActionView::Helpers::TagHelper
+      include ActionView::Helpers::TextHelper
+      attr_accessor :output_buffer
+      mattr_accessor :camelize_props_switch
+
+      # ControllerLifecycle calls these hooks
+      # You can use them in custom helper implementations
+      def setup(env)
+      end
+
+      def teardown(env)
+      end
+
+      # Render a UJS-type HTML tag annotated with data attributes, which
+      # are used by react_ujs to actually instantiate the React component
+      # on the client.
+      def react_component(name, props = {}, options = {}, &block)
+        options = {:tag => options} if options.is_a?(Symbol)
+        props = camelize_props_key(props) if camelize_props_switch
+
+        html_options = options.reverse_merge(:data => {})
+        html_options[:data].tap do |data|
+          data[:react_class] = name
+          data[:react_props] = (props.is_a?(String) ? props : props.to_json)
+        end
+        html_tag = html_options[:tag] || :div
+
+        # remove internally used properties so they aren't rendered to DOM
+        html_options.except!(:tag)
+
+        content_tag(html_tag, '', html_options, &block)
+      end
+
+      private
+
+      def camelize_props_key(props)
+        return props unless props.is_a?(Hash)
+        props.inject({}) do |h, (k,v)|
+          h[k.to_s.camelize(:lower)] = v.is_a?(Hash) ? camelize_props_key(v) : v; h
+        end
+      end
+    end
+  end
+end

data/lib/react/rails/version.rb

@@ -0,0 +1,7 @@
+module React
+  module Rails
+    # If you change this, make sure to update VERSIONS.md
+    # And the version hint in README.md, if needed
+    VERSION = '1.5.1'
+  end
+end

data/lib/react/rails/view_helper.rb

@@ -0,0 +1,25 @@
+module React
+  module Rails
+    module ViewHelper
+      # This class will be used for inserting tags into HTML.
+      # It should implement:
+      #   - #setup(controller_instance)
+      #   - #teardown(controller_instance)
+      #   - #react_component(name, props, options &block)
+      # The default is {React::Rails::ComponentMount}
+      mattr_accessor :helper_implementation_class
+
+      # Render a React component into the view
+      # using the {helper_implementation_class}
+      #
+      # If called during a Rails controller-managed request, use the instance
+      # created by the controller.
+      #
+      # Otherwise, make a new instance.
+      def react_component(*args, &block)
+        helper_obj = @__react_component_helper ||= helper_implementation_class.new
+        helper_obj.react_component(*args, &block)
+      end
+    end
+  end
+end

data/lib/react/rails.rb

@@ -0,0 +1,3 @@
+require 'react/rails/version'
+require 'react/rails/component_mount'
+require 'react/rails/view_helper'

data/lib/react-rails-stupid.rb

@@ -0,0 +1 @@
+require 'react/rails'

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: react-rails-stupid
+version: !ruby/object:Gem::Version
+  version: 1.5.1
+platform: ruby
+authors:
+- a-x-
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: coffee-script-source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: execjs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Compile your JSX on demand or precompile for production.
+email:
+- invntrm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/react-rails-stupid.rb
+- lib/react/rails.rb
+- lib/react/rails/component_mount.rb
+- lib/react/rails/version.rb
+- lib/react/rails/view_helper.rb
+homepage: https://github.com/reactjs/react-rails
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Stupid React/JSX adapter for the Ruby on Rails asset pipeline.
+test_files: []