RubyGems - hyper-react - Versions diffs - 0.12.7 → 0.99.0 - Mend

hyper-react 0.12.7 → 0.99.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (129) hide show

checksums.yaml +5 -5
data/.gitignore +48 -34
data/CODE_OF_CONDUCT.md +49 -0
data/Gemfile +5 -6
data/README.md +47 -98
data/Rakefile +6 -28
data/hyper-react.gemspec +36 -43
data/lib/hyper-react.rb +4 -73
data/lib/react/version.rb +3 -0
metadata +91 -249
data/.codeclimate.yml +0 -27
data/.rubocop.yml +0 -1159
data/.travis.yml +0 -62
data/Appraisals +0 -31
data/CHANGELOG.md +0 -143
data/LICENSE +0 -19
data/UPGRADING.md +0 -24
data/component-name-lookup.md +0 -145
data/config.ru +0 -26
data/gemfiles/opal_0.10_react_13.gemfile +0 -15
data/gemfiles/opal_0.10_react_14.gemfile +0 -15
data/gemfiles/opal_0.10_react_15.gemfile +0 -15
data/gemfiles/opal_0.8_react_13.gemfile +0 -15
data/gemfiles/opal_0.8_react_14.gemfile +0 -15
data/gemfiles/opal_0.8_react_15.gemfile +0 -15
data/gemfiles/opal_0.9_react_13.gemfile +0 -15
data/gemfiles/opal_0.9_react_14.gemfile +0 -15
data/gemfiles/opal_0.9_react_15.gemfile +0 -15
data/gemfiles/opal_master_react_15.gemfile +0 -16
data/lib/generators/reactive_ruby/test_app/templates/assets/javascripts/components.rb +0 -3
data/lib/generators/reactive_ruby/test_app/templates/assets/javascripts/test_application.rb +0 -2
data/lib/generators/reactive_ruby/test_app/templates/boot.rb.erb +0 -6
data/lib/generators/reactive_ruby/test_app/templates/script/rails +0 -5
data/lib/generators/reactive_ruby/test_app/templates/test_application.rb.erb +0 -13
data/lib/generators/reactive_ruby/test_app/templates/views/components/hello_world.rb +0 -11
data/lib/generators/reactive_ruby/test_app/templates/views/components/todo.rb +0 -14
data/lib/generators/reactive_ruby/test_app/templates/views/layouts/test_layout.html.erb +0 -0
data/lib/generators/reactive_ruby/test_app/test_app_generator.rb +0 -111
data/lib/rails-helpers/top_level_rails_component.rb +0 -54
data/lib/react-sources/react-server.js +0 -2
data/lib/react/api.rb +0 -173
data/lib/react/callbacks.rb +0 -41
data/lib/react/children.rb +0 -30
data/lib/react/component.rb +0 -168
data/lib/react/component/api.rb +0 -50
data/lib/react/component/base.rb +0 -13
data/lib/react/component/class_methods.rb +0 -189
data/lib/react/component/dsl_instance_methods.rb +0 -23
data/lib/react/component/params.rb +0 -6
data/lib/react/component/props_wrapper.rb +0 -78
data/lib/react/component/should_component_update.rb +0 -94
data/lib/react/component/tags.rb +0 -129
data/lib/react/config.rb +0 -5
data/lib/react/config/client.rb.erb +0 -19
data/lib/react/config/server.rb +0 -23
data/lib/react/element.rb +0 -169
data/lib/react/event.rb +0 -76
data/lib/react/ext/hash.rb +0 -9
data/lib/react/ext/opal-jquery/element.rb +0 -26
data/lib/react/ext/string.rb +0 -8
data/lib/react/hash.rb +0 -13
data/lib/react/native_library.rb +0 -87
data/lib/react/object.rb +0 -15
data/lib/react/react-source-browser.rb +0 -3
data/lib/react/react-source-server.rb +0 -3
data/lib/react/react-source.rb +0 -20
data/lib/react/ref_callback.rb +0 -31
data/lib/react/rendering_context.rb +0 -144
data/lib/react/server.rb +0 -23
data/lib/react/state_wrapper.rb +0 -23
data/lib/react/test.rb +0 -16
data/lib/react/test/dsl.rb +0 -17
data/lib/react/test/matchers/render_html_matcher.rb +0 -56
data/lib/react/test/rspec.rb +0 -15
data/lib/react/test/session.rb +0 -37
data/lib/react/test/utils.rb +0 -25
data/lib/react/top_level.rb +0 -118
data/lib/react/top_level_render.rb +0 -29
data/lib/react/validator.rb +0 -136
data/lib/reactive-ruby/component_loader.rb +0 -50
data/lib/reactive-ruby/isomorphic_helpers.rb +0 -212
data/lib/reactive-ruby/rails.rb +0 -7
data/lib/reactive-ruby/rails/component_mount.rb +0 -46
data/lib/reactive-ruby/rails/controller_helper.rb +0 -15
data/lib/reactive-ruby/rails/railtie.rb +0 -33
data/lib/reactive-ruby/serializers.rb +0 -15
data/lib/reactive-ruby/server_rendering/contextual_renderer.rb +0 -42
data/lib/reactive-ruby/version.rb +0 -3
data/lib/reactrb/auto-import.rb +0 -27
data/lib/reactrb/deep-compare.rb +0 -24
data/lib/reactrb/new-event-name-convention.rb +0 -11
data/logo1.png +0 -0
data/logo2.png +0 -0
data/logo3.png +0 -0
data/path_release_steps.md +0 -9
data/spec/controller_helper_spec.rb +0 -34
data/spec/index.html.erb +0 -11
data/spec/react/callbacks_spec.rb +0 -138
data/spec/react/children_spec.rb +0 -76
data/spec/react/component/base_spec.rb +0 -32
data/spec/react/component_spec.rb +0 -884
data/spec/react/dsl_spec.rb +0 -303
data/spec/react/element_spec.rb +0 -136
data/spec/react/event_spec.rb +0 -24
data/spec/react/native_library_spec.rb +0 -322
data/spec/react/observable_spec.rb +0 -42
data/spec/react/opal_jquery_extensions_spec.rb +0 -68
data/spec/react/param_declaration_spec.rb +0 -269
data/spec/react/react_spec.rb +0 -215
data/spec/react/refs_callback_spec.rb +0 -56
data/spec/react/server_spec.rb +0 -25
data/spec/react/state_spec.rb +0 -55
data/spec/react/test/dsl_spec.rb +0 -43
data/spec/react/test/matchers/render_html_matcher_spec.rb +0 -83
data/spec/react/test/rspec_spec.rb +0 -62
data/spec/react/test/session_spec.rb +0 -88
data/spec/react/test/utils_spec.rb +0 -28
data/spec/react/top_level_component_spec.rb +0 -101
data/spec/react/tutorial/tutorial_spec.rb +0 -36
data/spec/react/validator_spec.rb +0 -124
data/spec/reactive-ruby/component_loader_spec.rb +0 -77
data/spec/reactive-ruby/isomorphic_helpers_spec.rb +0 -160
data/spec/reactive-ruby/rails/asset_pipeline_spec.rb +0 -10
data/spec/reactive-ruby/rails/component_mount_spec.rb +0 -66
data/spec/reactive-ruby/server_rendering/contextual_renderer_spec.rb +0 -35
data/spec/spec_helper.rb +0 -149
data/spec/support/react/spec_helpers.rb +0 -44
data/spec/vendor/es5-shim.min.js +0 -6
data/spec/vendor/jquery-2.2.4.min.js +0 -4

data/lib/reactrb/deep-compare.rb DELETED

@@ -1,24 +0,0 @@
-# rubocop:disable Style/FileName
-# require 'reactrb/deep-compare' to get 0.9 deep compare behavior
-module React
-  module Component
-    module ShouldComponentUpdate
-      def props_changed?(next_params)
-        next_params != props
-      end
-      def call_needs_update(next_params, native_next_state)
-        component = self
-        next_params.define_singleton_method(:changed?) do
-          next_params != props
-        end
-        next_state = Hash.new(native_next_state)
-        next_state.define_singleton_method(:changed?) do
-          component.native_state_changed?(native_next_state)
-        end
-        needs_update?(next_params, next_state)
-      end
-    end
-  end
-end

data/lib/reactrb/new-event-name-convention.rb DELETED

@@ -1,11 +0,0 @@
-# rubocop:disable Style/FileName
-# require 'reactrb/new-event-name-convention' to remove missing param declaration "_onXXXX"
-if RUBY_ENGINE == 'opal'
-  # removes generation of the deprecated "_onXXXX" event param syntax
-  module React
-    class Element
-      def merge_deprecated_component_event_prop!(event_name)
-      end
-    end
-  end
-end

data/logo1.png DELETED

Binary file

data/logo2.png DELETED

Binary file

data/logo3.png DELETED

Binary file

data/path_release_steps.md DELETED

@@ -1,9 +0,0 @@
-For example assuming you are releasing fix to 0.8.18
-1. Checkout 0-8-stable
-2. Update tests, fix the bug and commit the changes.
-3. Build & Release to RubyGems (Remember the version in version.rb should already be 0.8.19)
-4. Create a tag 'v0.8.19' pointing to that commit.
-5. Bump the version in 0-8-stable to 0.8.20 so it will be ready for the next patch level release.
-6. Commit the version bump, and do a `git push --tags` so the new tag goes up

data/spec/controller_helper_spec.rb DELETED

@@ -1,34 +0,0 @@
-require 'spec_helper'
-if ruby?
-class TestController < ActionController::Base; end
-RSpec.describe TestController, type: :controller do
-  render_views
-  describe '#render_component' do
-    controller do
-      layout "test_layout"
-      def index
-        render_component
-      end
-      def new
-        render_component "Index", {}, layout: :explicit_layout
-      end
-    end
-    it 'renders with the default layout' do
-      get :index, no_prerender: true
-      expect(response).to render_template(layout: :test_layout)
-    end
-    it "renders with a specified layout" do
-      get :new, no_prerender: true
-      expect(response).to render_template(layout: :explicit_layout)
-    end
-  end
-end
-end

data/spec/index.html.erb DELETED

@@ -1,11 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="UTF-8" />
-</head>
-<body>
-  <%= javascript_include_tag 'vendor/es5-shim.min' %>
-  <%= javascript_include_tag 'vendor/jquery-2.2.4.min' %>
-  <%= javascript_include_tag @server.main %>
-</body>
-</html>

data/spec/react/callbacks_spec.rb DELETED

@@ -1,138 +0,0 @@
-require 'spec_helper'
-if opal?
-describe React::Callbacks do
-  it 'defines callback' do
-    stub_const 'Foo', Class.new
-    Foo.class_eval do
-      include React::Callbacks
-      define_callback :before_dinner
-      before_dinner :wash_hand
-      def wash_hand
-      end
-    end
-    instance = Foo.new
-    expect(instance).to receive(:wash_hand)
-    instance.run_callback(:before_dinner)
-  end
-  it 'defines multiple callbacks' do
-    stub_const 'Foo', Class.new
-    Foo.class_eval do
-      include React::Callbacks
-      define_callback :before_dinner
-      before_dinner :wash_hand, :turn_off_laptop
-      def wash_hand;end
-      def turn_off_laptop;end
-    end
-    instance = Foo.new
-    expect(instance).to receive(:wash_hand)
-    expect(instance).to receive(:turn_off_laptop)
-    instance.run_callback(:before_dinner)
-  end
-  context 'using Hyperloop::Context.reset!' do
-    after(:all) do
-      Hyperloop::Context.instance_variable_set(:@context, nil)
-    end
-    it 'clears callbacks on Hyperloop::Context.reset!' do
-      Hyperloop::Context.reset!
-      stub_const 'Foo', Class.new
-      Foo.class_eval do
-        include React::Callbacks
-        define_callback :before_dinner
-        before_dinner :wash_hand, :turn_off_laptop
-        def wash_hands;end
-        def turn_off_laptop;end
-      end
-      instance = Foo.new
-      expect(instance).to receive(:wash_hand).once
-      expect(instance).not_to receive(:turn_off_laptop)
-      Hyperloop::Context.reset!
-      instance.run_callback(:before_dinner)
-      Foo.class_eval do
-        before_dinner :wash_hand
-      end
-      instance.run_callback(:before_dinner)
-    end
-  end # moved elswhere cause its just hard to get anything to work in this environment
-  it 'defines block callback' do
-    stub_const 'Foo', Class.new
-    Foo.class_eval do
-      include React::Callbacks
-      attr_accessor :a
-      attr_accessor :b
-      define_callback :before_dinner
-      before_dinner do
-        self.a = 10
-      end
-      before_dinner do
-        self.b = 20
-      end
-    end
-    foo = Foo.new
-    foo.run_callback(:before_dinner)
-    expect(foo.a).to eq(10)
-    expect(foo.b).to eq(20)
-  end
-  it 'defines multiple callback group' do
-    stub_const 'Foo', Class.new
-    Foo.class_eval do
-      include React::Callbacks
-      define_callback :before_dinner
-      define_callback :after_dinner
-      attr_accessor :a
-      before_dinner do
-        self.a = 10
-      end
-    end
-    foo = Foo.new
-    foo.run_callback(:before_dinner)
-    foo.run_callback(:after_dinner)
-    expect(foo.a).to eq(10)
-  end
-  it 'receives args as callback' do
-    stub_const 'Foo', Class.new
-    Foo.class_eval do
-      include React::Callbacks
-      define_callback :before_dinner
-      define_callback :after_dinner
-      attr_accessor :lorem
-      before_dinner do |a, b|
-        self.lorem  = "#{a}-#{b}"
-      end
-      after_dinner :eat_ice_cream
-      def eat_ice_cream(a,b,c);  end
-    end
-    foo = Foo.new
-    expect(foo).to receive(:eat_ice_cream).with(4,5,6)
-    foo.run_callback(:before_dinner, 1, 2)
-    foo.run_callback(:after_dinner, 4, 5, 6)
-    expect(foo.lorem).to eq('1-2')
-  end
-end
-end

data/spec/react/children_spec.rb DELETED

@@ -1,76 +0,0 @@
-require 'spec_helper'
-if opal?
-describe React::Children do
-  let(:component) {
-    Class.new do
-      include React::Component
-      def render
-        div { 'lorem' }
-      end
-    end
-  }
-  let(:childs) { [React.create_element('a'), React.create_element('li')] }
-  let(:element) { React.create_element(component) { childs } }
-  let(:children) { described_class.new(`#{element.to_n}.props.children`) }
-  before(:each) do
-    React::Test::Utils.render_into_document(element)
-  end
-  it 'is enumerable' do
-    nodes = children.map { |elem| elem.element_type }
-    expect(nodes).to eq(['a', 'li'])
-  end
-  it 'returns an Enumerator when not providing a block' do
-    nodes = children.each
-    expect(nodes).to be_a(Enumerator)
-    expect(nodes.size).to eq(2)
-  end
-  describe '#each' do
-    it 'returns an array of elements' do
-      nodes = children.each { |elem| elem.element_type }
-      expect(nodes).to be_a(Array)
-      expect(nodes.map(&:class)).to eq(childs.map(&:class))
-    end
-  end
-  describe '#length' do
-    it 'returns the number of child elements' do
-      expect(children.length).to eq(2)
-    end
-  end
-  describe 'with single child element' do
-    let(:childs) { [React.create_element('a')] }
-    it 'is enumerable containing single element' do
-      nodes = children.map { |elem| elem.element_type }
-      expect(nodes).to eq(['a'])
-    end
-    describe '#length' do
-      it 'returns the number of child elements' do
-        expect(children.length).to eq(1)
-      end
-    end
-  end
-  describe 'with no child element' do
-    let(:element) { React.create_element(component) }
-    it 'is enumerable containing no elements' do
-      nodes = children.map { |elem| elem.element_type }
-      expect(nodes).to eq([])
-    end
-    describe '#length' do
-      it 'returns the number of child elements' do
-        expect(children.length).to eq(0)
-      end
-    end
-  end
-end
-end

data/spec/react/component/base_spec.rb DELETED

@@ -1,32 +0,0 @@
-require 'spec_helper'
-if opal?
-RSpec.describe React::Component::Base, type: :component do
-  after(:each) do
-    React::API.clear_component_class_cache
-  end
-  it 'can be inherited to create a component class' do
-    stub_const 'Foo', Class.new(React::Component::Base)
-    Foo.class_eval do
-      before_mount do
-        @instance_data = ["working"]
-      end
-      def render
-        @instance_data.first
-      end
-    end
-    stub_const 'Bar', Class.new(Foo)
-    Bar.class_eval do
-      before_mount do
-        @instance_data << "well"
-      end
-      def render
-        @instance_data.join(" ")
-      end
-    end
-    expect(Foo).to render_static_html("<span>working</span>")
-    expect(Bar).to render_static_html("<span>working well</span>")
-  end
-end
-end

data/spec/react/component_spec.rb DELETED

@@ -1,884 +0,0 @@
-require 'spec_helper'
-if opal?
-describe React::Component, type: :component do
-  after(:each) do
-    React::API.clear_component_class_cache
-  end
-  it 'defines component spec methods' do
-    stub_const 'Foo', Class.new
-    Foo.class_eval do
-      include React::Component
-      def initialize(native = nil)
-      end
-      def render
-        React.create_element('div')
-      end
-    end
-    # Class Methods
-    expect(Foo).to respond_to('initial_state')
-    expect(Foo).to respond_to('default_props')
-    expect(Foo).to respond_to('prop_types')
-    # Instance method
-    expect(Foo.new).to respond_to('component_will_mount')
-    expect(Foo.new).to respond_to('component_did_mount')
-    expect(Foo.new).to respond_to('component_will_receive_props')
-    expect(Foo.new).to respond_to('should_component_update?')
-    expect(Foo.new).to respond_to('component_will_update')
-    expect(Foo.new).to respond_to('component_did_update')
-    expect(Foo.new).to respond_to('component_will_unmount')
-  end
-  describe 'Life Cycle' do
-    let(:element_to_render) { React.create_element(Foo) }
-    before(:each) do
-      stub_const 'Foo', Class.new
-      Foo.class_eval do
-        include React::Component
-        def render
-          React.create_element('div') { 'lorem' }
-        end
-      end
-    end
-    it 'invokes `before_mount` registered methods when `componentWillMount()`' do
-      Foo.class_eval do
-        before_mount :bar, :bar2
-        def bar; end
-        def bar2; end
-      end
-      expect_any_instance_of(Foo).to receive(:bar)
-      expect_any_instance_of(Foo).to receive(:bar2)
-      React::Test::Utils.render_into_document(element_to_render)
-    end
-    it 'invokes `after_mount` registered methods when `componentDidMount()`' do
-      Foo.class_eval do
-        after_mount :bar3, :bar4
-        def bar3; end
-        def bar4; end
-      end
-      expect_any_instance_of(Foo).to receive(:bar3)
-      expect_any_instance_of(Foo).to receive(:bar4)
-      React::Test::Utils.render_into_document(element_to_render)
-    end
-    it 'allows multiple class declared life cycle hooker' do
-      stub_const 'FooBar', Class.new
-      Foo.class_eval do
-        before_mount :bar
-        def bar; end
-      end
-      FooBar.class_eval do
-        include React::Component
-        after_mount :bar2
-        def bar2; end
-        def render
-          React.create_element('div') { 'lorem' }
-        end
-      end
-      expect_any_instance_of(Foo).to receive(:bar)
-      React::Test::Utils.render_into_document(element_to_render)
-    end
-    it 'allows block for life cycle callback' do
-      Foo.class_eval do
-        before_mount do
-          set_state({ foo: "bar" })
-        end
-      end
-      instance = React::Test::Utils.render_into_document(element_to_render)
-      expect(instance.state[:foo]).to be('bar')
-    end
-  end
-  describe 'New style setter & getter' do
-    before(:each) do
-      stub_const 'Foo', Class.new
-      Foo.class_eval do
-        include React::Component
-        def render
-          div { state.foo }
-        end
-      end
-    end
-    it 'implicitly will create a state variable when first written' do
-      Foo.class_eval do
-        before_mount do
-          state.foo! 'bar'
-        end
-      end
-      expect(Foo).to render_static_html('<div>bar</div>')
-    end
-    it 'allows kernal method names like "format" to be used as state variable names' do
-      Foo.class_eval do
-        before_mount do
-          state.format! 'yes'
-          state.foo! state.format
-        end
-      end
-      expect(Foo).to render_static_html('<div>yes</div>')
-    end
-    it 'returns an observer with the bang method and no arguments' do
-      Foo.class_eval do
-        before_mount do
-          state.foo!(state.baz!.class.name)
-        end
-      end
-      expect(Foo).to render_static_html('<div>React::Observable</div>')
-    end
-    it 'returns the current value of a state when written' do
-      Foo.class_eval do
-        before_mount do
-          state.baz! 'bar'
-          state.foo!(state.baz!('pow'))
-        end
-      end
-      expect(Foo).to render_static_html('<div>bar</div>')
-    end
-    it 'can access an explicitly defined state`' do
-      Foo.class_eval do
-        define_state foo: :bar
-      end
-      expect(Foo).to render_static_html('<div>bar</div>')
-    end
-  end
-  describe 'State setter & getter' do
-    let(:element_to_render) { React.create_element(Foo) }
-    before(:each) do
-      stub_const 'Foo', Class.new
-      Foo.class_eval do
-        include React::Component
-        def render
-          React.create_element('div') { 'lorem' }
-        end
-      end
-    end
-    it 'defines setter using `define_state`' do
-      Foo.class_eval do
-        define_state :foo
-        before_mount :set_up
-        def set_up
-          mutate.foo 'bar'
-        end
-      end
-      instance = React::Test::Utils.render_into_document(element_to_render)
-      expect(instance.state.foo).to be('bar')
-    end
-    it 'defines init state by passing a block to `define_state`' do
-      Foo.class_eval do
-        define_state(:foo) { 10 }
-      end
-      instance = React::Test::Utils.render_into_document(element_to_render)
-      expect(instance.state.foo).to be(10)
-    end
-    it 'defines getter using `define_state`' do
-      Foo.class_eval do
-        define_state(:foo) { 10 }
-        before_mount :bump
-        def bump
-          mutate.foo(state.foo + 20)
-        end
-      end
-      instance = React::Test::Utils.render_into_document(element_to_render)
-      expect(instance.state.foo).to be(30)
-    end
-    it 'defines multiple state accessors by passing array to `define_state`' do
-      Foo.class_eval do
-        define_state :foo, :foo2
-        before_mount :set_up
-        def set_up
-          mutate.foo 10
-          mutate.foo2 20
-        end
-      end
-      instance = React::Test::Utils.render_into_document(element_to_render)
-      expect(instance.state.foo).to be(10)
-      expect(instance.state.foo2).to be(20)
-    end
-    it 'invokes `define_state` multiple times to define states' do
-      Foo.class_eval do
-        define_state(:foo) { 30 }
-        define_state(:foo2) { 40 }
-      end
-      instance = React::Test::Utils.render_into_document(element_to_render)
-      expect(instance.state.foo).to be(30)
-      expect(instance.state.foo2).to be(40)
-    end
-    it 'can initialize multiple state variables with a block' do
-      Foo.class_eval do
-        define_state(:foo, :foo2) { 30 }
-      end
-      instance = React::Test::Utils.render_into_document(element_to_render)
-      expect(instance.state.foo).to be(30)
-      expect(instance.state.foo2).to be(30)
-    end
-    it 'can mix multiple state variables with initializers and a block' do
-      Foo.class_eval do
-        define_state(:x, :y, foo: 1, bar: 2) {3}
-      end
-      instance = React::Test::Utils.render_into_document(element_to_render)
-      expect(instance.state.x).to be(3)
-      expect(instance.state.y).to be(3)
-      expect(instance.state.foo).to be(1)
-      expect(instance.state.bar).to be(2)
-    end
-    it 'gets state in render method' do
-      Foo.class_eval do
-        define_state(:foo) { 10 }
-        def render
-          React.create_element('div') { state.foo }
-        end
-      end
-      instance = React::Test::Utils.render_into_document(element_to_render)
-      expect(`#{instance.dom_node}.textContent`).to eq('10')
-    end
-    it 'supports original `setState` as `set_state` method' do
-      Foo.class_eval do
-        before_mount do
-          self.set_state(foo: 'bar')
-        end
-      end
-      instance = renderToDocument(Foo)
-      expect(instance.state[:foo]).to be('bar')
-    end
-    it 'supports original `replaceState` as `set_state!` method' do
-      Foo.class_eval do
-        before_mount do
-          set_state(foo: 'bar')
-          set_state!(bar: 'lorem')
-        end
-      end
-      element = renderToDocument(Foo)
-      puts "*************************************************************************************"
-      puts "element.state[:foo] = #{element.state[:foo]}"
-      puts "element.state[:bar] = #{element.state[:bar]}"
-      puts "*************************************************************************************"
-      expect(element.state[:foo]).to be_nil
-      expect(element.state[:bar]).to eq('lorem')
-    end
-    it 'supports original `state` method' do
-      Foo.class_eval do
-        before_mount do
-          self.set_state(foo: 'bar')
-        end
-        def render
-          div { self.state[:foo] }
-        end
-      end
-      expect(Foo).to render_static_html('<div>bar</div>')
-    end
-    it 'transforms state getter to Ruby object' do
-      Foo.class_eval do
-        define_state :foo
-        before_mount do
-          mutate.foo [{a: "Hello"}]
-        end
-        def render
-          div { state.foo[0][:a] }
-        end
-      end
-      expect(Foo).to render_static_html('<div>Hello</div>')
-    end
-  end
-  describe 'Props' do
-    describe 'this.props could be accessed through `params` method' do
-      before do
-        stub_const 'Foo', Class.new
-        Foo.class_eval do
-          include React::Component
-        end
-      end
-      it 'reads from parent passed properties through `params`' do
-        Foo.class_eval do
-          def render
-            React.create_element('div') { params[:prop] }
-          end
-        end
-        element = renderToDocument(Foo, prop: 'foobar')
-        expect(`#{element.dom_node}.textContent`).to eq('foobar')
-      end
-      it 'accesses nested params as orignal Ruby object' do
-        Foo.class_eval do
-          def render
-            React.create_element('div') { params[:prop][0][:foo] }
-          end
-        end
-        element = renderToDocument(Foo, prop: [{foo: 10}])
-        expect(`#{element.dom_node}.textContent`).to eq('10')
-      end
-    end
-    describe 'Props Updating', v13_only: true do
-      before do
-        stub_const 'Foo', Class.new
-        Foo.class_eval do
-          include React::Component
-        end
-      end
-      it 'supports original `setProps` as method `set_props`' do
-        Foo.class_eval do
-          def render
-            React.create_element('div') { params[:foo] }
-          end
-        end
-        element = renderToDocument(Foo, {foo: 10})
-        element.set_props(foo: 20)
-        expect(`#{element.dom_node}.innerHTML`).to eq('20')
-      end
-      it 'supports original `replaceProps` as method `set_props!`' do
-        Foo.class_eval do
-          def render
-            React.create_element('div') { params[:foo] ? 'exist' : 'null' }
-          end
-        end
-        instance = renderToDocument(Foo, {foo: 10})
-        instance.set_props!(bar: 20)
-        expect(`#{instance.dom_node}.innerHTML`).to eq('null')
-      end
-    end
-    describe 'Prop validation' do
-      before do
-        stub_const 'Foo', Class.new
-        Foo.class_eval do
-          include React::Component
-        end
-      end
-      it 'specifies validation rules using `params` class method' do
-        Foo.class_eval do
-          params do
-            requires :foo, type: String
-            optional :bar
-          end
-        end
-        expect(Foo.prop_types).to have_key(:_componentValidator)
-      end
-      it 'logs error in warning if validation failed' do
-        stub_const 'Lorem', Class.new
-        Foo.class_eval do
-          params do
-            requires :foo
-            requires :lorem, type: Lorem
-            optional :bar, type: String
-          end
-          def render; div; end
-        end
-        %x{
-          var log = [];
-          var org_warn_console =  window.console.warn;
-          var org_error_console = window.console.error;
-          window.console.warn = window.console.error = function(str){log.push(str)}
-        }
-        renderToDocument(Foo, bar: 10, lorem: Lorem.new)
-        `window.console.warn = org_warn_console; window.console.error = org_error_console;`
-        expect(`log[0]`).to match(/Warning: Failed prop( type|Type): In component `Foo`\nRequired prop `foo` was not specified\nProvided prop `bar` could not be converted to String/)
-      end
-      it 'should not log anything if validation pass' do
-        stub_const 'Lorem', Class.new
-        Foo.class_eval do
-          params do
-            requires :foo
-            requires :lorem, type: Lorem
-            optional :bar, type: String
-          end
-          def render; div; end
-        end
-        %x{
-          var log = [];
-          var org_warn_console = window.console.warn;
-          var org_error_console = window.console.error
-          window.console.warn = window.console.error = function(str){log.push(str)}
-        }
-        renderToDocument(Foo, foo: 10, bar: '10', lorem: Lorem.new)
-        `window.console.warn = org_warn_console; window.console.error = org_error_console;`
-        expect(`log`).to eq([])
-      end
-    end
-    describe 'Default props' do
-      it 'sets default props using validation helper' do
-        stub_const 'Foo', Class.new
-        Foo.class_eval do
-          include React::Component
-          params do
-            optional :foo, default: 'foo'
-            optional :bar, default: 'bar'
-          end
-          def render
-            div { params[:foo] + '-' + params[:bar]}
-          end
-        end
-        expect(Foo).to render_static_html('<div>lorem-bar</div>').with_params(foo: 'lorem')
-        expect(Foo).to render_static_html('<div>foo-bar</div>')
-      end
-    end
-  end
-  describe 'Anonymous Component' do
-    it "will not generate spurious warning messages" do
-      foo = Class.new(React::Component::Base)
-      foo.class_eval do
-        def render; "hello" end
-      end
-      %x{
-        var log = [];
-        var org_warn_console = window.console.warn;
-        var org_error_console = window.console.error
-        window.console.warn = window.console.error = function(str){log.push(str)}
-      }
-      renderToDocument(foo)
-      `window.console.warn = org_warn_console; window.console.error = org_error_console;`
-      expect(`log`).to eq([])
-    end
-  end
-  describe 'Render Error Handling' do
-    before(:each) do
-      %x{
-        window.test_log = [];
-        window.org_warn_console = window.console.warn;
-        window.org_error_console = window.console.error
-        window.console.warn = window.console.error = function(str){window.test_log.push(str)}
-      }
-    end
-    it "will generate a message if render returns something other than an Element or a String" do
-      foo = Class.new(React::Component::Base)
-      foo.class_eval do
-        def render; Hash.new; end
-      end
-      renderToDocument(foo)
-      `window.console.warn = window.org_warn_console; window.console.error = window.org_error_console;`
-      expect(`test_log`.first).to match /Instead the Hash \{\} was returned/
-    end
-    it "will generate a message if render returns a Component class" do
-      stub_const 'Foo', Class.new(React::Component::Base)
-      foo = Class.new(React::Component::Base)
-      foo.class_eval do
-        def render; Foo; end
-      end
-      renderToDocument(foo)
-      `window.console.warn = window.org_warn_console; window.console.error = window.org_error_console;`
-      expect(`test_log`.first).to match /Did you mean Foo()/
-    end
-    it "will generate a message if more than 1 element is generated" do
-      foo = Class.new(React::Component::Base)
-      foo.class_eval do
-        def render; "hello".span; "goodby".span; end
-      end
-      renderToDocument(foo)
-      `window.console.warn = window.org_warn_console; window.console.error = window.org_error_console;`
-      expect(`test_log`.first).to match /Instead 2 elements were generated/
-    end
-    it "will generate a message if the element generated is not the element returned" do
-      foo = Class.new(React::Component::Base)
-      foo.class_eval do
-        def render; "hello".span; "goodby".span.delete; end
-      end
-      renderToDocument(foo)
-      `window.console.warn = window.org_warn_console; window.console.error = window.org_error_console;`
-      expect(`test_log`.first).to match /A different element was returned than was generated within the DSL/
-    end
-  end
-  describe 'Event handling' do
-    before do
-      stub_const 'Foo', Class.new
-      Foo.class_eval do
-        include React::Component
-      end
-    end
-    it 'works in render method' do
-      Foo.class_eval do
-        define_state(:clicked) { false }
-        def render
-          React.create_element('div').on(:click) do
-            mutate.clicked true
-          end
-        end
-      end
-      element = React.create_element(Foo)
-      instance = React::Test::Utils.render_into_document(element)
-      React::Test::Utils.simulate(:click, instance)
-      expect(instance.state.clicked).to eq(true)
-    end
-    it 'invokes handler on `this.props` using emit' do
-      Foo.class_eval do
-        param :_onFooSubmit, type: Proc
-        after_mount :setup
-        def setup
-          puts "***************************** about to emit******************************"
-          self.emit(:foo_submit, 'bar')
-          puts "***************************** emitted!!! ********************************"
-        rescue Exception => e
-          puts "FAILED FAILED FAILED #{e}"
-        end
-        def render
-          React.create_element('div')
-        end
-      end
-      expect { |b|
-        element = React.create_element(Foo).on(:foo_submit, &b)
-        React::Test::Utils.render_into_document(element)
-      }.to yield_with_args('bar')
-    end
-    it 'invokes handler with multiple params using emit' do
-      Foo.class_eval do
-        param :_onFooInvoked, type: Proc
-        after_mount :setup
-        def setup
-          self.emit(:foo_invoked, [1,2,3], 'bar')
-        end
-        def render
-          React.create_element('div')
-        end
-      end
-      expect { |b|
-        element = React.create_element(Foo).on(:foo_invoked, &b)
-        React::Test::Utils.render_into_document(element)
-      }.to yield_with_args([1,2,3], 'bar')
-    end
-  end
-  describe '#refs' do
-    before do
-      stub_const 'Foo', Class.new
-      Foo.class_eval do
-        include React::Component
-      end
-    end
-    it 'correctly assigns refs' do
-      Foo.class_eval do
-        def render
-          React.create_element('input', type: :text, ref: :field)
-        end
-      end
-      instance = renderToDocument(Foo)
-      expect(instance.refs[:field]).not_to be_nil
-    end
-    it 'accesses refs through `refs` method' do
-      Foo.class_eval do
-        def render
-          React.create_element('input', type: :text, ref: :field).on(:click) do
-            refs[:field].value = 'some_stuff'
-          end
-        end
-      end
-      instance = React::Test::Utils.render_into_document(React.create_element(Foo))
-      React::Test::Utils.simulate(:click, instance)
-      expect(instance.refs[:field].value).to eq('some_stuff')
-    end
-    it "allows access the actual DOM node", v13_exclude: true do
-      Foo.class_eval do
-        after_mount do
-          dom = refs[:my_div].to_n
-          `dom.innerHTML = 'Modified'`
-        end
-        def render
-          React.create_element('div', ref: :my_div) { "Original Content" }
-        end
-      end
-      instance = renderToDocument(Foo)
-      expect(`#{instance.dom_node}.innerHTML`).to eq('Modified')
-    end
-  end
-  describe '#render' do
-    it 'supports element building helpers' do
-      stub_const 'Foo', Class.new
-      Foo.class_eval do
-        include React::Component
-        def render
-          div do
-            span { params[:foo] }
-          end
-        end
-      end
-      stub_const 'Bar', Class.new
-      Bar.class_eval do
-        include React::Component
-        def render
-          div do
-            present Foo, foo: 'astring'
-          end
-        end
-      end
-      expect(Bar).to render_static_html('<div><div><span>astring</span></div></div>')
-    end
-    it 'builds single node in top-level render without providing a block' do
-      stub_const 'Foo', Class.new
-      Foo.class_eval do
-        include React::Component
-        def render
-          div
-        end
-      end
-      expect(Foo).to render_static_html('<div></div>')
-    end
-    it 'redefines `p` to make method missing work' do
-      stub_const 'Foo', Class.new
-      Foo.class_eval do
-        include React::Component
-        def render
-          div {
-            p(class_name: 'foo')
-            p
-            div { 'lorem ipsum' }
-            p(id: '10')
-          }
-        end
-      end
-      markup = '<div><p class="foo"></p><p></p><div>lorem ipsum</div><p id="10"></p></div>'
-      expect(Foo).to render_static_html(markup)
-    end
-    it 'only overrides `p` in render context' do
-      stub_const 'Foo', Class.new
-      Foo.class_eval do
-        include React::Component
-        before_mount do
-          p 'first'
-        end
-        after_mount do
-          p 'second'
-        end
-        def render
-          div
-        end
-      end
-      expect(Kernel).to receive(:p).with('first')
-      expect(Kernel).to receive(:p).with('second')
-      renderToDocument(Foo)
-    end
-  end
-  describe 'isMounted()' do
-    it 'returns true if after mounted' do
-      stub_const 'Foo', Class.new
-      Foo.class_eval do
-        include React::Component
-        def render
-          React.create_element('div')
-        end
-      end
-      component = renderToDocument(Foo)
-      expect(component.mounted?).to eq(true)
-    end
-  end
-  describe '.params_changed?' do
-    before(:each) do
-      stub_const 'Foo', Class.new(React::Component::Base)
-      Foo.define_method :needs_update? do |next_params, next_state|
-        next_params.changed?
-      end
-      @foo = Foo.new(nil)
-    end
-    it "returns false if new and old params are the same" do
-      @foo.instance_variable_set("@native", `{props: {value1: 1, value2: 2}}`)
-      expect(@foo.should_component_update?(`{value2: 2, value1: 1}`, `null`)).to be_falsy
-    end
-    it "returns true if new and old params are have different values" do
-      @foo.instance_variable_set("@native", `{props: {value1: 1, value2: 2}}`)
-      expect(@foo.should_component_update?(`{value2: 2, value1: 2}`, `null`)).to be_truthy
-    end
-    it "returns true if new and old params are have different keys" do
-      @foo.instance_variable_set("@native", `{props: {value1: 1, value2: 2}}`)
-      expect(@foo.should_component_update?(`{value2: 2, value1: 1, value3: 3}`, `null`)).to be_truthy
-    end
-  end
-  describe '#state_changed?' do
-    empties = [`{}`, `undefined`, `null`, `false`]
-    before(:each) do
-      stub_const 'Foo', Class.new(React::Component::Base)
-      Foo.define_method :needs_update? do |next_params, next_state|
-        next_state.changed?
-      end
-      @foo = Foo.new(nil)
-    end
-    it "returns false if both new and old states are empty" do
-      empties.each do |empty1|
-        empties.each do |empty2|
-          @foo.instance_variable_set("@native", `{state: #{empty1}}`)
-          expect(@foo.should_component_update?(`{}`, empty2)).to be_falsy
-        end
-      end
-    end
-    it "returns true if old state is empty, but new state is not" do
-      empties.each do |empty|
-        @foo.instance_variable_set("@native", `{state: #{empty}}`)
-        expect(@foo.should_component_update?(`{}`, `{foo: 12}`)).to be_truthy
-      end
-    end
-    it "returns true if new state is empty, but old state is not" do
-      empties.each do |empty|
-        @foo.instance_variable_set("@native", `{state: {foo: 12}}`)
-        expect(@foo.should_component_update?(`{}`, empty)).to be_truthy
-      end
-    end
-    it "returns true if new state and old state have different time stamps" do
-      @foo.instance_variable_set("@native", `{state: {'***_state_updated_at-***': 12}}`)
-      expect(@foo.should_component_update?(`{}`, `{'***_state_updated_at-***': 13}`)).to be_truthy
-    end
-    it "returns false if new state and old state have the same time stamps" do
-      @foo.instance_variable_set("@native", `{state: {'***_state_updated_at-***': 12}}`)
-      expect(@foo.should_component_update?(`{}`, `{'***_state_updated_at-***': 12}`)).to be_falsy
-    end
-  end
-  describe '#children' do
-    before(:each) do
-      stub_const 'Foo', Class.new
-      Foo.class_eval do
-        include React::Component
-        def render
-          React.create_element('div') { 'lorem' }
-        end
-      end
-    end
-    it 'returns React::Children collection with child elements' do
-      ele = React.create_element(Foo) {
-        [React.create_element('a'), React.create_element('li')]
-      }
-      instance = React::Test::Utils.render_into_document(ele)
-      children = instance.children
-      expect(children).to be_a(React::Children)
-      expect(children.count).to eq(2)
-      expect(children.map(&:element_type)).to eq(['a', 'li'])
-    end
-    it 'returns an empty Enumerator if there are no children' do
-      ele = React.create_element(Foo)
-      instance = React::Test::Utils.render_into_document(ele)
-      nodes = instance.children.each
-      expect(nodes.size).to eq(0)
-      expect(nodes.count).to eq(0)
-    end
-  end
-end
-end