reactive-ruby 0.7.36 → 0.7.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53fab6aeafe7118f114372c43eb59da36686edce
-  data.tar.gz: ae2204d49647a1dc551b31e94da088409ede0706
+  metadata.gz: 23600ed81f6cdbfd4492addb059c2fc226147f32
+  data.tar.gz: 7ae2faaeacc75627e86614168cd7a79f250165a8
 SHA512:
-  metadata.gz: 63cbb7816492eadb362c81f5ceceaf81b5abbf2ffbb37cc8a625a2826d2f797bec710329f01ab3c768418238b2a0fbd20dc98a37c662132a9f32acce55463629
-  data.tar.gz: d854e781186cf9b1f8a99fa438b36eb2803ec529d251846ee42e6a6884502db3dee79758de4c7d92e71192ad6c0d2ba7a65a6e57fe62d396887f5626416484a4
+  metadata.gz: b56872543b2db22c8b3682de518415f84a7753c0402365cbf39679d13aa5e16d7c65ae756d92917646cd51283d05671aeef33d85e662a2e82ef63cd9c60991fc
+  data.tar.gz: 787ef02379630312653277931881a916f8183f9998f634fb01545b78083102518e63de11fb120dcde63f70ac8ccdae318e8a7874410b2bd994316bb1dd9ebe33

data/README.md

@@ -11,225 +11,94 @@
 It lets you write reactive UI components, with Ruby's elegance using the tried
 and true React.js engine. :heart:
 
-[**Visit Our Documentation Site For The Full Story**](https://reactive-ruby.github.io)
+[**Visit reactrb.org For The Full Story**](http://reactrb.org)
 
-### What's this Reactive Ruby?
+### Important: current `react.rb` gem users please [read this!](#road-map)
 
-Reactive Ruby started as a fork of the original react.rb gem, and has since been
-merged back into react.rb's master branch. It aims to take react.rb a few steps
-further by embracing it's 'Ruby-ness'.
+## Installation 
 
-Reactive-Ruby is maturing, but is still a work in progress. Currently it is
-being used in a large rails app. However the gem itself has no dependency on
-rails, and there are people using the gem in other environments.
+Install the gem, or load the js library
 
-Stable react.rb can be found in the
-[0-3-stable](https://github.com/zetachang/react.rb/tree/0-3-stable) branch.
++ add `gem 'reactive-ruby'` to your gem file or
++ `gem install reactive-ruby` or
++ install (or load via cdn) [inline-reactive-ruby.js](http://github.com/reactive-ruby/inline-reactive-ruby)
 
-## Quick Overview
-
-A react app is built from one or more trees of components.  React components can
-live side by side with other non-react html and javascript. A react component is
-just like a rails view or a partial.  Reactive-Ruby takes advantage of these
-features by letting you add Reactive-Ruby components as views, and call them
-directly from your controller like any other view.
-
-By design Reactive-Ruby allows reactive components  to be easily added to
-existing Rails projects, as well in new development.
-
-Components are first rendered to HTML on the server (called pre-rendering) this
-is no different from what happens when your ERB or HAML templates are translated
-to HTML.
-
-A copy of the react engine, and your components follows the rendered HTML to the
-browser, and then when a user interacts with the page, it is updated on the
-client.
-
-The beauty is you now have one markup description, written in the same language
-as your server code, that works both as the HTML template and as an interactive
-component.
-
-See the [wiki](https://github.com/zetachang/react.rb/wiki) for more details.
-
-## Using React.rb with Rails
-
-### Installation
-
-In your Gemfile:
-
-```ruby
-gem 'reactive-ruby'
-gem 'react-rails', '~> 1.3.2'
-gem 'opal-rails', '~> 0.8.1'
-gem 'therubyracer', platforms: :ruby # Required for prerendering
-# for JRuby you need the below line instead
-# gem 'therubyrhino, platforms: :jruby
-
-```
-
-Run `bundle install` and restart your rails server.
-
-### Both Client & Server Side Assets (Components)
-
-Your react components will go into the `app/views/components/` directory of your
-rails app.
-
-Within your `app/views` directory you need to create a `components.rb` manifest.
-Files required in `app/views/components.rb` will be made available to the server
-side rendering system as well as the browser.
-
-```
-# app/views/components.rb
-require 'opal'
-require 'reactive-ruby'
-require_tree './components'
-```
-
-### Client Side Assets
-
-In `assets/javascript/application.rb` require your components manifest as well
-as any additional browser only assets.
+For gem installation it is highly recommended to read [the getting started section at reactrb.org](http://reactrb.org/docs/getting-started.html)
 
-```
-# assets/javascript/application.rb
-# Require files that are browser side only.
-
-# Make components available by requiring your components.rb manifest.
-require 'components'
-
-# 'react_ujs' tells react in the browser to mount rendered components.
-require 'react_ujs'
-
-# Finally, require your other javascript assets. jQuery for example...
-require 'jquery'      # You need both these files to access jQuery from Opal.
-require 'opal-jquery' # They must be in this order.
-```
-
-### Rendering Components
-
-Components may be rendered directly from a controller action by simply following
-a naming convention. To render a component from the `home#show` action, create a
-component class named `Show`.  For details on how to override this behavior, and how the the module tree is searched for
-the class see the next section.
-
-```ruby
-# app/views/components/home/show.rb
-module Components
-  module Home
-    class Show
-      include React::Component # will create a new component named Show
-
-      optional_param :say_hello_to
-
-      def render
-        puts "Rendering my first component!"
-
-        # render "hello" with optional 'say_hello_to' param
-        "hello #{say_hello_to if say_hello_to}"
-      end
-    end
-  end
-end
-```
-
-Call `render_component` in the controller action passing in any params (React
-props), to render the component:
+## Quick Overview
 
-```ruby
-# controllers/home_controller.rb
-class HomeController < ApplicationController
-  def show
-    # render_component uses the controller name to find the 'show' component.
-    render_component say_hello_to: params[:say_hello_to]
-  end
-end
-```
+React.rb components are ruby classes that inherit from `React::Component::Base` or include `React::Component`.
 
-Make sure your routes file has a route to your home#show action. Visit that
-route in your browser and you should see 'Hello' rendered.
+`React::Component` provides a complete DSL to generate html and event handlers, and has full set of class macros to define states, parameters, and lifecycle callbacks.
 
-Open up the js console in the browser and you will see a log showing what went
-on during rendering.
+Each react component class has a render method that generates the markup for that component.
 
-Have a look at the sources in the console, and notice your ruby code is there,
-and you can set break points etc.
+Each react component class defines a new tag-method in the DSL that works just like built-in html tags, so react components can render other react components.
 
-### Changing the top level component name and search path
+As events occur, components update their state, which causes them to rerender, and perhaps pass new parameters to lower level components, thus causing them to rerender.  
 
-You can control the top level component name and search path.
+Under the hood the actual work is effeciently done by the [React.js](http://facebook.github.io/react/) engine. 
 
-By default the component class name is inferred from the controller method rendering the component.
-You can also specify the component name explicitly in the `render_component` method.
-`render_component "Blatz` will search the for a component class named `Blatz`
-regardless of the name of the controller method.
+React.rb components are *isomorphic* meaning they can run on the server as well as the client.  This means that the initial expansion of the component tree to markup is done server side, just like ERB, or HAML templates.   Then the same code runs on the client and will respond to any events.   
 
-Searching for components works like this:  Given a controller named
-"Foo" then react.rb will search for a module named `Foo` containing the component.
-If this fails all modules will be searched (i.e. the name of the controller will be
-ignored.)  In either case the search begins at the outer most scope until a match is made.
+React.rb integrates well with Rails, Sinatra, and simple static sites, and can be added to existing web pages very easily, or it can be used to deliver complete websites.
 
-Thus for example given a controller named `Foo`, components could be found in the `Foo` module,
-the `Components::Foo` module, in the outer most scope, or in any nested module.
-The way the search works allows for small projects that do not need a lot
-of name spacing, and also allows components to be shared across several controllers.
+## Why ?
 
-Saying `render_component "::Blatz"` will only search the outer scope, while
-`"::Bar::Blatz"` will look only in the module `Bar` for a class named `Blatz`.
++ *Single Language:*  Use Ruby everywhere, no JS, markup languages, or JSX
++ *Powerful DSL:* Describe HTML and event handlers with a minimum of fuss
++ *Ruby Goodness:* Use all the features of Ruby to create reusable, maintainable UI code
++ *React Simplicity:* Nothing is taken away from the React.js model
++ *Enhanced Features:* Enhanced parameter and state management and other new features
++ *Plays well with Others:* Works with other frameworks, React.js components, Rails, Sinatra and static web pages
 
+# Problems, Questions, Issues
 
-## Integration with Sinatra
++ [Stack Overflow](http://stackoverflow.com/questions/tagged/react.rb) tag `react.rb` for specific problems.
++ [Gitter.im](https://gitter.im/zetachang/react.rb) for general questions, discussion, and interactive help.
++ [Github Issues](https://github.com/zetachang/react.rb/issues) for bugs, feature enhancements, etc.
 
-See the [sinatra example](https://github.com/zetachang/react.rb/tree/master/example/sinatra-tutorial).
 
-## Contextual Code
+# Road Map
 
-Sometimes it may be necessary to run code only on the server or only in the
-browser. To execute code only during server side rendering:
+The original `react.rb` gem is still available as the [0-3-stable branch.](https://github.com/zetachang/react.rb/tree/0-3-stable) **but please read on..**
 
-```ruby
-if React::IsomorphicHelpers.on_opal_server?
-  puts 'Hello from the server'
-end
-```
+Many new features, bug fixes, and improvements are incoporated in the `reactive-ruby` gem currently built on the [0-7-stable branch.](https://github.com/zetachang/react.rb/tree/0-7-stable)  In addtion more extensive documentation for the current stable branch  is available at [reactrb.org](http://reactrb.org), and the [Opal Ruby Playground](http://fkchang.github.io/opal-playground/?code:&html_code=%3Cdiv%20id%3D%22container%22%3E%3C%2Fdiv%3E%0A&css_code=body%20%7B%0A%20%20background%3A%20%23eeeeee%3B%0A%7D%0A) incorporates the current stable branch.
 
-To execute code only in the browser:
+Our plan is to do one more upgrade on the `reactive-ruby` gem which will be designated version 0.8.0. [click for detailed feature list](https://github.com/zetachang/react.rb/milestones/0.8.x)
 
-```ruby
-if React::IsomorphicHelpers.on_opal_client?
-  puts 'Hello from the browser'
-end
-```
+From 0.9.0 and beyond we will return to using the `react.rb` gem for releases, and `reactive-ruby` will continue as a meta gem that depends only on react.rb >= 0.9.x.
 
-## Typical Problems
+Version 0.9.0 of `react.rb` **will not be** 100% backward compatible with 0.3.0 so its very important to begin your upgrade process now by switching to `reactive-ruby` 0.7.0.
 
-`Uncaught TypeError: Cannot read property 'toUpperCase' of undefined`  This
-means the thing you are trying to render is not actually a react component.
-Often is because the top level component name is wrong.  For example if you are
-in controller Foo and the method is `bar`, but you have named the component
-Foo::Bars then you would see this message.
+Please let us know either at [Gitter.im](https://gitter.im/zetachang/react.rb) or [via an issue](https://github.com/zetachang/react.rb/issues) if you have specific concerns with the upgrade from 0.3.0 to 0.9.0.
 
-## Turning off Prerendering
+## Developing
 
-Sometimes its handy to switch off prerendering.  Add `?no_prerender=1` ... to
-your url.
+`git clone` the project.
 
+To play with some live examples cd to the project directory then 
 
-## TODOS / Work arounds / Issues
+2. `cd example/examples`
+2. `bundle install`
+3. `bundle exec rackup`
+4. Open `http://localhos:9292`
 
-* Documentation
-* Should load the RubyRacer, or at least report an error if the RubyRacer is not
-  present
-* Get everything to autoload what it needs (i.e. much less config setup)
+or 
 
-## Developing
+1. `cd example/rails-tutorial`
+2. `bundle install`
+3. `bundle exec rails s`
+4. Open `http://localhost:3000`
 
-To run the above examples project yourself:
+or
 
-1. `git clone` the project
-2. `cd example/tutorial`
+1. `cd example/sinatra-tutorial`
 2. `bundle install`
 3. `bundle exec rackup`
-4. Open `http://localhost`
+4. Open `http://localhost:9292`
+
+Note that these are very simple examples, for the purpose of showing how to configure the gem in various server environments.  For more  examples and information see [reactrb.org.](http://reactrb.org)
 
 ## Testing
 
@@ -238,14 +107,9 @@ To run the above examples project yourself:
 
 ## Contributions
 
-This project is still in early stage, so discussion, bug report and PR are
-really welcome :wink:.  We check in often at
-https://gitter.im/zetachang/react.rb ask for @catmando as David is on leave
-right now.
-
-## Contact
+This project is still in early stage, so discussion, bug reports and PRs are
+really welcome :wink:.   
 
-We check in often at https://gitter.im/zetachang/react.rb ask for @catmando.
 
 ## License
 

data/lib/react/component/props_wrapper.rb

@@ -33,7 +33,7 @@ module React
           end
         else
           define_method("#{name}") do
-            if param_type.respond_to? :_react_param_conversion
+            @processed_params[name] ||= if param_type.respond_to? :_react_param_conversion
               param_type._react_param_conversion props[name]
             elsif param_type.is_a?(Array) &&
               param_type[0].respond_to?(:_react_param_conversion)
@@ -49,6 +49,7 @@ module React
 
       def initialize(props)
         @props = props || {}
+        @processed_params = {}
       end
 
       def [](prop)

data/lib/reactive-ruby/version.rb

@@ -1,3 +1,3 @@
 module React
-  VERSION = "0.7.36"
+  VERSION = "0.7.38"
 end

data/spec/react/param_declaration_spec.rb

@@ -195,6 +195,27 @@ describe 'the param macro' do
       expect(`window.dummy_log`).to eq(["Warning: Failed propType: In component `Foo`\nProvided prop `foo` could not be converted to BazWoggle"])
     end
 
+    it "can will only convert once" do
+      stub_const "BazWoggle", Class.new
+      BazWoggle.class_eval do
+        def initialize(kind)
+          @kind = kind
+        end
+        attr_accessor :kind
+        def self._react_param_conversion(json, validate_only)
+          new(json[:bazwoggle]) if json[:bazwoggle]
+        end
+      end
+      Foo.class_eval do
+        param :foo, type: BazWoggle
+        def render
+          params.foo.kind = params.foo.kind+1
+          "#{params.foo.kind}"
+        end
+      end
+      expect(React.render_to_static_markup(React.create_element(Foo, foo: {bazwoggle: 1}))).to eq('<span>2</span>')
+    end
+
     it "will alias a Proc type param" do
       Foo.class_eval do
         param :foo, type: Proc

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reactive-ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.36
+  version: 0.7.38
 platform: ruby
 authors:
 - David Chang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-22 00:00:00.000000000 Z
+date: 2016-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal