hyper-react 0.12.7 → 0.99.0

data/spec/react/test/rspec_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-if opal?
-  RSpec.describe 'react/test/rspec', type: :component do
-    before do
-      stub_const 'Greeter', Class.new
-      Greeter.class_eval do
-        include React::Component
-        params do
-          optional :message
-          optional :from
-        end
-
-        def render
-          span { "Hello #{params.message}" }
-        end
-      end
-    end
-
-    it 'should include react/test in rspec' do
-      comp = mount(Greeter)
-      expect(component.instance).to eq(comp)
-    end
-
-    it 'includes rspec matchers' do
-      expect(Greeter).to render_static_html(
-        '<span>Hello world</span>'
-      ).with_params(message: 'world')
-    end
-
-    describe 'resetting the session' do
-      it 'creates an instance of the mounted component in one example' do
-        mount(Greeter)
-      end
-
-      it '...then is not availalbe in the next' do
-        expect { component.instance }.to raise_error
-      end
-    end
-  end
-
-  RSpec.describe 'react/test/rspec', type: :other do
-    before do
-      stub_const 'Greeter', Class.new
-      Greeter.class_eval do
-        include React::Component
-        params do
-          optional :message
-          optional :from
-        end
-
-        def render
-          span { "Hello #{params.message}" }
-        end
-      end
-    end
-
-    it 'should not include react/test in rspec' do
-      expect { mount(Greeter) }.to raise_error
-    end
-  end
-end

data/spec/react/test/session_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-if opal?
-  RSpec.describe React::Test::Session do
-    subject { described_class.new }
-    before do
-      stub_const 'Greeter', Class.new
-      Greeter.class_eval do
-        include React::Component
-
-        params do
-          optional :message
-          optional :from
-        end
-
-        def render
-          span { "Hello #{params.message}" }
-        end
-      end
-    end
-
-    describe '#mount' do
-      it 'returns an instance of the mounted component' do
-        expect(subject.mount(Greeter)).to be_a(Greeter)
-      end
-
-      it 'actualy mounts the component' do
-        expect(subject.mount(Greeter)).to be_mounted
-      end
-
-      it 'optionaly passes params to the component' do
-        instance = subject.mount(Greeter, message: 'world')
-        expect(instance.params.message).to eq('world')
-      end
-    end
-
-    describe '#instance' do
-      it 'returns the instance of the mounted component' do
-        instance = subject.mount(Greeter)
-        expect(subject.instance).to eq(instance)
-      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
-
-      async 'returns the updated static html' do
-        subject.mount(Greeter)
-        subject.update_params(message: 'moon') do
-          run_async {
-            expect(subject.html).to eq('<span>Hello moon</span>')
-          }
-        end
-      end
-    end
-
-    describe '#update_params' do
-      it 'sends new params to the component' do
-        instance = subject.mount(Greeter, message: 'world')
-        subject.update_params(message: 'moon')
-        expect(instance.params.message).to eq('moon')
-      end
-
-      it 'leaves unspecified params in tact' do
-        instance = subject.mount(Greeter, message: 'world', from: 'outerspace')
-        subject.update_params(message: 'moon')
-        expect(instance.params.from).to eq('outerspace')
-      end
-
-      it 'causes the component to render' do
-        instance = subject.mount(Greeter, message: 'world')
-        expect(instance).to receive(:render)
-        subject.update_params(message: 'moon')
-      end
-    end
-
-    describe 'instance#force_update!' do
-      it 'causes the component to render' do
-        instance = subject.mount(Greeter)
-        expect(instance).to receive(:render)
-        subject.instance.force_update!
-      end
-    end
-  end
-end

data/spec/react/test/utils_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-if opal?
-  RSpec.describe React::Test::Utils do
-    it 'simulates' do
-      stub_const 'Foo', Class.new
-      Foo.class_eval do
-        include React::Component
-
-        def render
-          div { 'Click Me' }.on(:click) { |e| click(e) }
-        end
-      end
-
-      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

@@ -1,101 +0,0 @@
-require 'spec_helper'
-
-if opal?
-module Components
-  module Controller
-    class Component1
-      include React::Component
-      def render
-        self.class.name.to_s
-      end
-    end
-  end
-
-  class Component1
-    include React::Component
-    def render
-      self.class.name.to_s
-    end
-  end
-
-  class Component2
-    include React::Component
-    def render
-      self.class.name.to_s
-    end
-  end
-end
-
-module Controller
-  class SomeOtherClass  # see issue #80
-  end
-end
-
-class Component1
-  include React::Component
-  def render
-    self.class.name.to_s
-  end
-end
-
-def render_top_level(controller, component_name)
-  params = {
-    controller: controller,
-    component_name: component_name,
-    render_params: {}
-  }
-  element = React.create_element(React::TopLevelRailsComponent, params)
-  React::Server.render_to_static_markup(element)
-end
-
-describe React::TopLevelRailsComponent do
-
-  it 'uses the controller name to lookup a component' do
-    expect(render_top_level("Controller", "Component1")).to eq('<span>Components::Controller::Component1</span>')
-  end
-
-  it 'can find the name without matching the controller' do
-    expect(render_top_level("Controller", "Component2")).to eq('<span>Components::Component2</span>')
-  end
-
-  it 'will find the outer most matching component' do
-    expect(render_top_level("OtherController", "Component1")).to eq('<span>Component1</span>')
-  end
-
-  it 'can find the correct component when the name is fully qualified' do
-    expect(render_top_level("Controller", "::Components::Component1")).to eq('<span>Components::Component1</span>')
-  end
-
-  describe '.html_tag?' do
-    it 'is truthy for valid html tags' do
-      expect(React.html_tag?('a')).to be_truthy
-      expect(React.html_tag?('div')).to be_truthy
-    end
-
-    it 'is truthy for valid svg tags' do
-      expect(React.html_tag?('svg')).to be_truthy
-      expect(React.html_tag?('circle')).to be_truthy
-    end
-
-    it 'is falsey for invalid tags' do
-      expect(React.html_tag?('tagizzle')).to be_falsey
-    end
-  end
-
-  describe '.html_attr?' do
-    it 'is truthy for valid html attributes' do
-      expect(React.html_attr?('id')).to be_truthy
-      expect(React.html_attr?('data')).to be_truthy
-    end
-
-    it 'is truthy for valid svg attributes' do
-      expect(React.html_attr?('cx')).to be_truthy
-      expect(React.html_attr?('strokeWidth')).to be_truthy
-    end
-
-    it 'is falsey for invalid attributes' do
-      expect(React.html_tag?('attrizzle')).to be_falsey
-    end
-  end
-end
-end

data/spec/react/tutorial/tutorial_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-if opal?
-class HelloMessage
-  include React::Component
-  def render
-    div { "Hello World!" }
-  end
-end
-
-describe 'An Example from the react.rb doc', type: :component do
-  it 'produces the correct result' do
-    expect(HelloMessage).to render_static_html('<div>Hello World!</div>')
-  end
-end
-
-class HelloMessage2
-  include React::Component
-  define_state(:user_name) { '@catmando' }
-  def render
-    div { "Hello #{state.user_name}" }
-  end
-end
-
-describe 'Adding state to a component (second tutorial example)', type: :component do
-  it "produces the correct result" do
-    expect(HelloMessage2).to render_static_html('<div>Hello @catmando</div>')
-  end
-
-  it 'renders to the document' do
-    ele = `document.createElement('div')`
-    React.render(React.create_element(HelloMessage2), ele)
-    expect(`#{ele}.innerHTML`) =~ 'Hello @catmando'
-  end
-end
-end

data/spec/react/validator_spec.rb

@@ -1,124 +0,0 @@
-require "spec_helper"
-
-if opal?
-describe React::Validator do
-  describe '#validate' do
-    describe "Presence validation" do
-      it "should check if required props provided" do
-        validator = React::Validator.new.build do
-          requires :foo
-          requires :bar
-        end
-
-        expect(validator.validate({})).to eq(["Required prop `foo` was not specified", "Required prop `bar` was not specified"])
-        expect(validator.validate({foo: 1, bar: 3})).to eq([])
-      end
-
-      it "should check if passed non specified prop" do
-        validator = React::Validator.new.build do
-          optional :foo
-        end
-
-        expect(validator.validate({bar: 10})).to eq(["Provided prop `bar` not specified in spec"])
-        expect(validator.validate({foo: 10})).to eq([])
-      end
-    end
-
-    describe "Type validation" do
-      it "should check if passed value with wrong type" do
-        validator = React::Validator.new.build do
-          requires :foo, type: String
-        end
-
-        expect(validator.validate({foo: 10})).to eq(["Provided prop `foo` could not be converted to String"])
-        expect(validator.validate({foo: "10"})).to eq([])
-      end
-
-      it "should check if passed value with wrong custom type" do
-        stub_const 'Bar', Class.new
-        validator = React::Validator.new.build do
-          requires :foo, type: Bar
-        end
-
-        expect(validator.validate({foo: 10})).to eq(["Provided prop `foo` could not be converted to Bar"])
-        expect(validator.validate({foo: Bar.new})).to eq([])
-      end
-
-      it 'coerces native JS prop types to opal objects' do
-        validator = React::Validator.new.build do
-          requires :foo, type: `{ x: 1 }`
-        end
-
-        message = "Provided prop `foo` could not be converted to [object Object]"
-        expect(validator.validate({foo: `{ x: 1 }`})).to eq([message])
-      end
-
-      it 'coerces native JS values to opal objects' do
-        validator = React::Validator.new.build do
-          requires :foo, type: Array[Fixnum]
-        end
-        message = "Provided prop `foo`[0] could not be converted to #{Fixnum.name}"
-        expect(validator.validate({foo: `[ { x: 1 } ]`})).to eq([message])
-      end
-
-      it "should support Array[Class] validation" do
-        validator = React::Validator.new.build do
-          requires :foo, type: Array[Hash]
-        end
-
-        expect(validator.validate({foo: [1,'2',3]})).to eq(
-          [
-            "Provided prop `foo`[0] could not be converted to Hash",
-            "Provided prop `foo`[1] could not be converted to Hash",
-            "Provided prop `foo`[2] could not be converted to Hash"
-          ]
-        )
-        expect(validator.validate({foo: [{},{},{}]})).to eq([])
-      end
-    end
-
-    describe "Limited values" do
-      it "should check if passed value is not one of the specified values" do
-        validator = React::Validator.new.build do
-          requires :foo, values: [4,5,6]
-        end
-
-        expect(validator.validate({foo: 3})).to eq(["Value `3` for prop `foo` is not an allowed value"])
-        expect(validator.validate({foo: 4})).to eq([])
-      end
-    end
-  end
-
-  describe '#undefined_props' do
-    let(:props) { { foo: 'foo', bar: 'bar', biz: 'biz', baz: 'baz' } }
-    let(:validator) do
-      React::Validator.new.build do
-        requires :foo
-        optional :bar
-      end
-    end
-
-    it 'slurps up any extra params into a hash' do
-      others = validator.undefined_props(props)
-      expect(others).to eq({ biz: 'biz', baz: 'baz' })
-    end
-
-    it 'prevents validate non-specified params' do
-      validator.undefined_props(props)
-      expect(validator.validate(props)).to eq([])
-    end
-  end
-
-  describe "default_props" do
-    it "should return specified default values" do
-      validator = React::Validator.new.build do
-        requires :foo, default: 10
-        requires :bar
-        optional :lorem, default: 20
-      end
-
-      expect(validator.default_props).to eq({foo: 10, lorem: 20})
-    end
-  end
-end
-end

data/spec/reactive-ruby/component_loader_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-if ruby?
-RSpec.describe ReactiveRuby::ComponentLoader do
-  GLOBAL_WRAPPER = <<-JS
-    #{React::ServerRendering::ExecJSRenderer::GLOBAL_WRAPPER}
-    var console = {
-      warn: function(s) {  }
-    };
-  JS
-
-  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) }
-
-  describe '.new' do
-    it 'raises a meaningful exception when initialized without a context' do
-      expect {
-        described_class.new(nil)
-      }.to raise_error(/Could not obtain ExecJS runtime context/)
-    end
-  end
-
-  describe '#load' do
-    it 'loads given asset file into context' do
-      loader = described_class.new(v8_context)
-
-      expect {
-        loader.load
-      }.to change { !!v8_context.eval('Opal.React') }.from(false).to(true)
-    end
-
-    it 'is truthy upon successful load' do
-      loader = described_class.new(v8_context)
-      expect(loader.load).to be_truthy
-    end
-
-    it 'fails silently returning false' do
-      loader = described_class.new(v8_context)
-      expect(loader.load('foo')).to be_falsey
-    end
-  end
-
-  describe '#load!' do
-    it 'is truthy upon successful load' do
-      loader = described_class.new(v8_context)
-      expect(loader.load!).to be_truthy
-    end
-
-    it 'raises an expection if loading fails' do
-      loader = described_class.new(v8_context)
-      expect { loader.load!('foo') }.to raise_error(/No react\.rb components/)
-    end
-  end
-
-  describe '#loaded?' do
-    it 'is truthy if components file is already loaded' do
-      loader = described_class.new(v8_context)
-      loader.load
-      expect(loader).to be_loaded
-    end
-
-    it 'is false if components file is not loaded' do
-      loader = described_class.new(v8_context)
-      expect(loader).to_not be_loaded
-    end
-  end
-end
-end