hyper-react 0.10.0 → 0.11.0

data/spec/react/param_declaration_spec.rb

@@ -12,7 +12,7 @@ describe 'the param macro', type: :component do
       end
     end
 
-    expect(Foo).to render('<div>biz</div>').with_params(bar: 'biz')
+    expect(Foo).to render_static_html('<div>biz</div>').with_params(bar: 'biz')
   end
 
   it "can create and access a required param" do
@@ -25,7 +25,7 @@ describe 'the param macro', type: :component do
       end
     end
 
-    expect(Foo).to render('<div>bar</div>').with_params(foo: :bar)
+    expect(Foo).to render_static_html('<div>bar</div>').with_params(foo: :bar)
   end
 
   it "can create and access an optional params" do
@@ -42,7 +42,7 @@ describe 'the param macro', type: :component do
       end
     end
 
-    expect(Foo).to render('<div>bar1-no_bar2-bar3-no_bar4</div>').with_params(foo1: :bar1, foo3: :bar3)
+    expect(Foo).to render_static_html('<div>bar1-no_bar2-bar3-no_bar4</div>').with_params(foo1: :bar1, foo3: :bar3)
   end
 
   it 'can specify validation rules with the type option' do
@@ -66,7 +66,7 @@ describe 'the param macro', type: :component do
       end
     end
 
-    expect(Foo).to render('<div>12-string</div>').with_params(foo1: 12, foo2: "string")
+    expect(Foo).to render_static_html('<div>12-string</div>').with_params(foo1: 12, foo2: "string")
   end
 
   it 'logs error in warning if validation failed' do
@@ -167,7 +167,7 @@ describe 'the param macro', type: :component do
       end
 
       params = { foo: "", bar: { bazwoggle: 1 }, baz: [{ bazwoggle: 2 }] }
-      expect(Foo).to render('<span>1, 2</span>').with_params(params)
+      expect(Foo).to render_static_html('<span>1, 2</span>').with_params(params)
       expect(`window.dummy_log[0]`).to match(/Warning: Failed prop( type|Type): In component `Foo`\nProvided prop `foo` could not be converted to BazWoggle/)
     end
 
@@ -190,7 +190,7 @@ describe 'the param macro', type: :component do
             "#{params.foo.kind}"
           end
         end
-        expect(React.render_to_static_markup(React.create_element(Foo, foo: {bazwoggle: 1}))).to eq('<span>2</span>')
+        expect(Foo).to render_static_html('<span>2</span>').with_params(foo: {bazwoggle: 1})
       end
 
       it "even if contains an embedded native object" do
@@ -235,7 +235,7 @@ describe 'the param macro', type: :component do
           params.foo
         end
       end
-      expect(Foo).to render('<span>works!</span>').with_params(foo: lambda { 'works!' })
+      expect(Foo).to render_static_html('<span>works!</span>').with_params(foo: lambda { 'works!' })
     end
 
     it "will create a 'bang' (i.e. update) method if the type is React::Observable" do
@@ -250,7 +250,7 @@ describe 'the param macro', type: :component do
       end
       current_state = ""
       observer = React::Observable.new(current_state) { |new_state| current_state = new_state }
-      expect(Foo).to render('<span>ha!</span>').with_params(foo: observer)
+      expect(Foo).to render_static_html('<span>ha!</span>').with_params(foo: observer)
       expect(current_state).to eq("ha!")
     end
   end

data/spec/react/react_spec.rb

@@ -6,28 +6,28 @@ RSpec.describe React, type: :component do
     React::API.clear_component_class_cache
   end
 
-  describe "is_valid_element" do
+  describe "is_valid_element?" do
     it "should return true if passed a valid element" do
       element = React::Element.new(`React.createElement('div')`)
-      expect(React.is_valid_element(element)).to eq(true)
+      expect(React.is_valid_element?(element)).to eq(true)
     end
 
     it "should return false is passed a non React element" do
       element = React::Element.new(`{}`)
-      expect(React.is_valid_element(element)).to eq(false)
+      expect(React.is_valid_element?(element)).to eq(false)
     end
   end
 
   describe "create_element" do
     it "should create a valid element with only tag" do
       element = React.create_element('div')
-      expect(React.is_valid_element(element)).to eq(true)
+      expect(React.is_valid_element?(element)).to eq(true)
     end
 
     context "with block" do
       it "should create a valid element with text as only child when block yield String" do
         element = React.create_element('div') { "lorem ipsum" }
-        expect(React.is_valid_element(element)).to eq(true)
+        expect(React.is_valid_element?(element)).to eq(true)
         expect(element.props.children).to eq("lorem ipsum")
       end
 
@@ -35,7 +35,7 @@ RSpec.describe React, type: :component do
         element = React.create_element('div') do
           [React.create_element('span'), React.create_element('span'), React.create_element('span')]
         end
-        expect(React.is_valid_element(element)).to eq(true)
+        expect(React.is_valid_element?(element)).to eq(true)
         expect(element.props.children.length).to eq(3)
       end
 
@@ -43,8 +43,9 @@ RSpec.describe React, type: :component do
         element = React.create_element('div') do
           [React.create_element('span'), React.create_element('span'), React.create_element('span')]
         end
-        instance = renderElementToDocument(element)
-        expect(Element[instance].children.length).to eq(3)
+        dom_node = React::Test::Utils.render_into_document(element)
+
+        expect(`#{dom_node}.children.length`).to eq(3)
       end
     end
 
@@ -52,29 +53,37 @@ RSpec.describe React, type: :component do
       before do
         stub_const 'Foo', Class.new
         Foo.class_eval do
+          def initialize(native)
+            @native = native
+          end
+
           def render
             React.create_element("div") { "lorem" }
           end
+
+          def props
+            Hash.new(`#@native.props`)
+          end
         end
       end
 
       it "should render element with only one children correctly" do
         element = React.create_element(Foo) { React.create_element('span') }
-        instance = renderElementToDocument(element)
-        expect(instance.props.children).not_to be_a(Array)
-        expect(instance.props.children.type).to eq("span")
+        instance = React::Test::Utils.render_into_document(element)
+        expect(instance.props[:children]).not_to be_a(Array)
+        expect(instance.props[:children][:type]).to eq("span")
       end
 
       it "should render element with more than one children correctly" do
         element = React.create_element(Foo) { [React.create_element('span'), React.create_element('span')] }
-        instance = renderElementToDocument(element)
-        expect(instance.props.children).to be_a(Array)
-        expect(instance.props.children.length).to eq(2)
+        instance = React::Test::Utils.render_into_document(element)
+        expect(instance.props[:children]).to be_a(Array)
+        expect(instance.props[:children].length).to eq(2)
       end
 
       it "should create a valid element provided class defined `render`" do
         element = React.create_element(Foo)
-        expect(React.is_valid_element(element)).to eq(true)
+        expect(React.is_valid_element?(element)).to eq(true)
       end
 
       it "should allow creating with properties" do
@@ -102,14 +111,14 @@ RSpec.describe React, type: :component do
           end
         end
 
-        expect(Foo).to render("<div>20</div>")
+        expect(Foo).to render_static_html("<div>20</div>")
       end
 
       it "should match the instance cycle to ReactComponent life cycle" do
         `var count = 0;`
 
         Foo.class_eval do
-          def initialize
+          def initialize(native)
             `count = count + 1;`
           end
           def render
@@ -117,8 +126,8 @@ RSpec.describe React, type: :component do
           end
         end
 
-        renderToDocument(Foo)
-        renderToDocument(Foo)
+        React::Test::Utils.render_into_document(React.create_element(Foo))
+        React::Test::Utils.render_into_document(React.create_element(Foo))
 
         expect(`count`).to eq(2)
       end
@@ -172,19 +181,23 @@ RSpec.describe React, type: :component do
       React.render(React.create_element('span') { "lorem" }, div)
     end
 
-    it "should return a React::Component::API compatible object" do
-      div = `document.createElement("div")`
-      component = React.render(React.create_element('span') { "lorem" }, div)
-      React::Component::API.public_instance_methods(true).each do |method_name|
-        expect(component).to respond_to(method_name)
+    it "returns the actual ruby instance" do
+      stub_const 'Foo', Class.new
+      Foo.class_eval do
+        def render
+          React.create_element("div") { "lorem" }
+        end
       end
+
+      div = `document.createElement("div")`
+      instance = React.render(React.create_element(Foo), div)
+      expect(instance).to be_a(Foo)
     end
 
-    pending "should return nil to prevent abstraction leakage" do
+    it "returns the actual DOM node" do
       div = `document.createElement("div")`
-      expect {
-        React.render(React.create_element('span') { "lorem" }, div)
-      }.to be_nil
+      node = React.render(React.create_element('span') { "lorem" }, div)
+      expect(`#{node}.nodeType`).to eq(1)
     end
   end
 

data/spec/react/test/rspec_spec.rb

@@ -23,7 +23,7 @@ if opal?
     end
 
     it 'includes rspec matchers' do
-      expect(Greeter).to render(
+      expect(Greeter).to render_static_html(
         '<span>Hello world</span>'
       ).with_params(message: 'world')
     end

data/spec/react/test/session_spec.rb

@@ -41,31 +41,19 @@ if opal?
       end
     end
 
-    describe '#element' do
-      it 'returns the React::Element for the mounted component' do
-        subject.mount(Greeter)
-        expect(subject.element).to be_a(React::Element)
-      end
-    end
-
-    describe '#native' do
-      it 'returns the React native instance of the component' do
-        instance = subject.mount(Greeter)
-        native = instance.instance_variable_get('@native')
-        expect(subject.native).to eq(native)
-      end
-    end
-
     describe '#html' do
       it 'returns the component rendered to static html' do
         subject.mount(Greeter, message: 'world')
         expect(subject.html).to eq('<span>Hello world</span>')
       end
 
-      it 'returns the updated static html' do
+      async 'returns the updated static html' do
         subject.mount(Greeter)
-        subject.update_params(message: 'moon')
-        expect(subject.html).to eq('<span>Hello moon</span>')
+        subject.update_params(message: 'moon') do
+          run_async {
+            expect(subject.html).to eq('<span>Hello moon</span>')
+          }
+        end
       end
     end
 
@@ -89,11 +77,11 @@ if opal?
       end
     end
 
-    describe '#force_update' do
+    describe 'instance#force_update!' do
       it 'causes the component to render' do
         instance = subject.mount(Greeter)
         expect(instance).to receive(:render)
-        subject.force_update!
+        subject.instance.force_update!
       end
     end
   end

data/spec/react/test/utils_spec.rb

@@ -1,45 +1,28 @@
 require 'spec_helper'
 
 if opal?
-  module React
-    module Test
-      class Utils
-        def self.simulate(event, element)
-          Simulate.new.click(element)
-        end
-
-        class Simulate
-          include Native
-          def initialize
-            super(`React.addons.TestUtils.Simulate`)
-          end
-
-          def click(component_instance)
-            `#{@native}['click']`.call(component_instance.dom_node, {})
-          end
-        end
-      end
-    end
-  end
   RSpec.describe React::Test::Utils do
     it 'simulates' do
       stub_const 'Foo', Class.new
       Foo.class_eval do
         include React::Component
 
-        def hello
-          @hello
-        end
-
         def render
-          @hello = 'hello'
           div { 'Click Me' }.on(:click) { |e| click(e) }
         end
       end
 
-      instance = renderToDocument(Foo)
-      expect_any_instance_of(Foo).to receive(:click)
-      described_class.simulate(:click, instance)
+      instance = React::Test::Utils.render_into_document(React.create_element(Foo))
+      expect(instance).to receive(:click)
+      described_class.simulate(:click, instance.dom_node)
+    end
+
+    describe "render_into_document" do
+      it "works with native element" do
+        expect {
+          described_class.render_into_document(React.create_element('div'))
+        }.to_not raise_error
+      end
     end
   end
 end

data/spec/react/top_level_component_spec.rb

@@ -39,8 +39,13 @@ class Component1
 end
 
 def render_top_level(controller, component_name)
-  render_to_html(React::TopLevelRailsComponent, controller: controller,
-                 component_name: component_name, render_params: {})
+  params = {
+    controller: controller,
+    component_name: component_name,
+    render_params: {}
+  }
+  element = React.create_element(React::TopLevelRailsComponent, params)
+  React.render_to_static_markup(element)
 end
 
 describe React::TopLevelRailsComponent do

data/spec/react/tutorial/tutorial_spec.rb

@@ -10,7 +10,7 @@ end
 
 describe 'An Example from the react.rb doc', type: :component do
   it 'produces the correct result' do
-    expect(HelloMessage).to render('<div>Hello World!</div>')
+    expect(HelloMessage).to render_static_html('<div>Hello World!</div>')
   end
 end
 
@@ -24,7 +24,7 @@ end
 
 describe 'Adding state to a component (second tutorial example)', type: :component do
   it "produces the correct result" do
-    expect(HelloMessage2).to render('<div>Hello @catmando</div>')
+    expect(HelloMessage2).to render_static_html('<div>Hello @catmando</div>')
   end
 
   it 'renders to the document' do

data/spec/reactive-ruby/component_loader_spec.rb

@@ -3,15 +3,21 @@ require 'spec_helper'
 if ruby?
 RSpec.describe ReactiveRuby::ComponentLoader do
   GLOBAL_WRAPPER = <<-JS
-    var global = global || this;
-    var self = self || this;
-    var window = window || this;
+    #{React::ServerRendering::ExecJSRenderer::GLOBAL_WRAPPER}
     var console = {
       warn: function(s) {  }
     };
   JS
 
-  let(:js) { ::Rails.application.assets['components'].to_s }
+  let(:js) do
+    if ::Rails.application.assets['react-server.js'] &&
+       !::Rails.application.assets['react-server.js'].to_s.start_with?("// A placeholder file")
+      react_source = ::Rails.application.assets['react-server.js']
+    else
+      react_source = ::Rails.application.assets['react.js']
+    end
+    ::Rails.application.assets['components'].to_s + react_source.to_s
+  end
   let(:context) { ExecJS.compile(GLOBAL_WRAPPER + js) }
   let(:v8_context) { ReactiveRuby::ServerRendering.context_instance_for(context) }
 

data/spec/reactive-ruby/isomorphic_helpers_spec.rb

@@ -77,7 +77,12 @@ if ruby?
     end
 
     def react_context
-      test_context('components')
+      if ::Rails.application.assets['react-server.js'] &&
+         !::Rails.application.assets['react-server.js'].to_s.start_with?("// A placeholder file")
+        test_context(['components', 'react-server.js'])
+      else
+        test_context(['components', 'react.js'])
+      end
     end
 
     let(:v8_context) { TestV8Context.new }

data/spec/spec_helper.rb

@@ -18,6 +18,8 @@ if RUBY_ENGINE == 'opal'
   require 'react/react-source'
   require 'hyper-react'
   require 'react/test/rspec'
+  require 'react/test/utils'
+  require 'react/top_level_render'
 
   require File.expand_path('../support/react/spec_helpers', __FILE__)
 

data/spec/support/react/spec_helpers.rb

@@ -3,29 +3,9 @@ module React
   module SpecHelpers
     `var ReactTestUtils = React.addons.TestUtils`
 
-    def render_to_html(type, options = {})
-      element = React.create_element(type, options)
-      React.render_to_static_markup(element)
-    end
-
     def renderToDocument(type, options = {})
       element = React.create_element(type, options)
-      renderElementToDocument(element)
-    end
-
-    def renderElementToDocument(element)
-      instance = Native(`ReactTestUtils.renderIntoDocument(#{element.to_n})`)
-      instance.class.include(React::Component::API)
-      instance
-    end
-
-    def simulateEvent(event, element, params = {})
-      simulator = Native(`ReactTestUtils.Simulate`)
-      simulator[event.to_s].call(element.dom_node, params)
-    end
-
-    def isElementOfType(element, type)
-      `React.addons.TestUtils.isElementOfType(#{element.to_n}, #{type.cached_component_class})`
+      React::Test::Utils.render_into_document(element)
     end
 
     def build_element(type, options)