reactive-ruby 0.7.28 → 0.7.29

data/spec/react/dsl_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+if opal?
+describe 'the React DSL' do
+  it "will treat the component class name as a first class component name"  # Foo()
+  it "can add class names by the haml .class notation"                      # Foo.my_class
+  it "can use the 'class' keyword for classes"                              # Foo(class: "my-class")
+  it "will turn the last string in a block into a span"                     # Foo { "hello there" }
+  it "has a .span short hand String method"                                 # "hello there".span
+  it "has a .br short hand String method"
+  it "has a .td short hand String method"
+  it "has a .para short hand String method"
+  it "can generate a unrendered node using the .as_node method"             # div { "hello" }.as_node
+  it "can use the dangerously_set_inner_HTML param"                         # div { dangerously_set_inner_HTML: "<div>danger</div>" }
+end
+end

data/{opal-spec → spec/react}/element_spec.rb

@@ -1,12 +1,13 @@
 require "spec_helper"
 
+if opal?
 describe React::Element do
-  it "should bridge `type` of native React.Element attributes" do
+  it 'bridges `type` of native React.Element attributes' do
     element = React.create_element('div')
     expect(element.element_type).to eq("div")
   end
 
-  async "should be renderable" do
+  async 'is renderable' do
     element = React.create_element('span')
     div = `document.createElement("div")`
     React.render(element, div) do
@@ -16,8 +17,8 @@ describe React::Element do
     end
   end
 
-  describe "Event subscription" do
-    it "should be subscribable through `on(:event_name)` method" do
+  describe 'Event subscription' do
+    it 'is subscribable through `on(:event_name)` method' do
       expect { |b|
         element = React.create_element("div").on(:click, &b)
         instance = renderElementToDocument(element)
@@ -37,24 +38,10 @@ describe React::Element do
       }.to yield_control
     end
 
-    it "should return self for `on` method" do
+    it 'returns self for `on` method' do
       element = React.create_element("div")
       expect(element.on(:click){}).to eq(element)
     end
   end
-
-  describe "Children" do
-    it "should return a Enumerable" do
-      ele = React.create_element('div') { [React.create_element('a'), React.create_element('li')] }
-      nodes = ele.children.map {|ele| ele.element_type }
-      expect(nodes).to eq(["a", "li"])
-    end
-
-    it "should return a Enumerator when not providing a block" do
-      ele = React.create_element('div') { [React.create_element('a'), React.create_element('li')] }
-      nodes = ele.children.each
-      expect(nodes).to be_a(Enumerator)
-      expect(nodes.size).to eq(2)
-    end
-  end
+end
 end

data/{opal-spec → spec/react}/event_spec.rb

@@ -1,5 +1,6 @@
 require "spec_helper"
 
+if opal?
 describe React::Event do
   it "should bridge attributes of native SyntheticEvent (see http://facebook.github.io/react/docs/events.html#syntheticevent)" do
     element = React.create_element('div').on(:click) do |event|
@@ -19,4 +20,5 @@ describe React::Event do
     instance = renderElementToDocument(element)
     simulateEvent(:click, instance)
   end
-end
+end
+end

data/spec/react/native_library_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+if opal?
+describe React::NativeLibrary do
+  it "will import a React.js library into the Ruby name space"              # class BS < NativeLibrary; imports 'ReactBootstrap'; end
+  it "exclude specific components from a library"                           # exclude "Modal" # can't access BS.Modal
+  it "rename specific components from a library"                            # rename "Modal" => "FooBar"  # BS.FooBar connects to ReactBootstrap.Modal
+  it "can importan multiple libraries into one class"                       
+end
+end

data/spec/react/param_declaration_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+if opal?
+describe 'the required_param macro' do
+  it "can be used to declare a required param"                              # required_param :foo
+  it "can have a simple type"                                               # required_param :foo, type: String
+  it "can use the [] notation for arrays"                                   # required_param :foo, type: []
+  it "can use the [] notation for arrays of a specific type"                # required_param :foo, type: [String]
+  it "can convert a json hash to a type"                                    # required_param :foo, type: BazWoggle # requires a BazWoggle conversion be provided
+  it "will alias a Proc type param"                                         # required_param :foo, type: Proc # we can just say foo(...) to call the proc
+  it "will bind a two way linkage to an observable param"                   # required_param :foo, type: React::Observable # defines foo, and foo! bound to the observer
+    # you can create an observable simply by passing the value of some state!
+end
+describe 'the optional_param macro' do
+  # works just like a required_param, and
+  it "can have a default value"                                             # optional_param :foo, type: String, default: ""
+end
+end

data/{opal-spec → spec/react}/react_spec.rb

@@ -1,5 +1,6 @@
 require "spec_helper"
 
+if opal?
 describe React do
   after(:each) do
     React::API.clear_component_class_cache
@@ -46,6 +47,7 @@ describe React do
         expect(instance.getDOMNode.childNodes.length).to eq(3)
       end
     end
+
     describe "custom element" do
       before do
         stub_const 'Foo', Class.new
@@ -155,7 +157,6 @@ describe React do
     end
   end
 
-
   describe "render" do
     async "should render element to DOM" do
       div = `document.createElement("div")`
@@ -205,5 +206,5 @@ describe React do
       end
     end
   end
-
+end
 end

data/spec/react/react_state_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+if opal?
+
+describe 'React::State' do
+  # class Foo; export_state :foo; end # accessible as Foo.foo outside
+  it "can created static exported states" do
+    stub_const 'Foo', Class.new
+    Foo.class_eval do
+      include React::Component
+      export_state(:foo) { 'bar' }
+    end
+
+    expect(Foo.foo).to eq('bar')
+  end
+
+  # these will all require async operations and testing to see if things get re-rendered see spec_helper the "render" test method
+  it "sets up observers when exported states are read"                      # if Foo.foo is used during rendering then when Foo.foo changes we will rerender
+  it "can be accessed outside of react using get/set_state"                 # React::State.set_state(object, attribute, value) + React::State.get_state(object, attribute)
+end
+
+end

data/spec/react/top_level_component_spec.rb

@@ -0,0 +1,68 @@
+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)
+  React.render_to_static_markup(React.create_element(
+    React::TopLevelRailsComponent, {controller: controller, component_name: component_name, render_params: {}}))
+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
+
+end
+end

data/{opal-spec → spec/react}/tutorial/tutorial_spec.rb

@@ -1,18 +1,17 @@
-require "spec_helper"
-  
+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" do
-  
-  it "produces the correct result" do
+
+describe 'An Example from the react.rb doc' do
+  it 'produces the correct result' do
     expect(React.render_to_static_markup(React.create_element(HelloMessage))).to eq('<div>Hello World!</div>')
   end
-  
 end
 
 class HelloMessage2
@@ -23,15 +22,14 @@ class HelloMessage2
   end
 end
 
-describe "Adding state to a component (second tutorial example)" do
-  
+describe 'Adding state to a component (second tutorial example)' do
   it "produces the correct result" do
     expect(React.render_to_static_markup(React.create_element(HelloMessage2))).to eq('<div>Hello @catmando</div>')
   end
-  
-  it "renders to the document" do
+
+  it 'renders to the document' do
     React.render(React.create_element(HelloMessage2), `document.getElementById('render_here')`)
     expect(`document.getElementById('render_here').innerHTML`) =~ 'Hello @catmando'
   end
-  
-end
+end
+end

data/{opal-spec → spec/react}/validator_spec.rb

@@ -1,7 +1,8 @@
 require "spec_helper"
 
+if opal?
 describe React::Validator do
-  describe "validate" do
+  describe '#validate' do
     describe "Presence validation" do
       it "should check if required props provided" do
         validator = React::Validator.build do
@@ -29,7 +30,7 @@ describe React::Validator do
           requires :foo, type: String
         end
 
-        expect(validator.validate({foo: 10})).to eq(["Provided prop `foo` was not the specified type `String`"])
+        expect(validator.validate({foo: 10})).to eq(["Provided prop `foo` could not be converted to String"])
         expect(validator.validate({foo: "10"})).to eq([])
       end
 
@@ -39,16 +40,40 @@ describe React::Validator do
           requires :foo, type: Bar
         end
 
-        expect(validator.validate({foo: 10})).to eq(["Provided prop `foo` was not the specified type `Bar`"])
+        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.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.build do
+          requires :foo, type: Array[Fixnum]
+        end
+
+        message = "Provided prop `foo`[0] could not be converted to Numeric"
+        expect(validator.validate({foo: `[ { x: 1 } ]`})).to eq([message])
+      end
+
       it "should support Array[Class] validation" do
         validator = React::Validator.build do
           requires :foo, type: Array[Hash]
         end
 
-        expect(validator.validate({foo: [1,'2',3]})).to eq(["Provided prop `foo` was not an Array of the specified type `Hash`"])
+        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
@@ -65,6 +90,26 @@ describe React::Validator do
     end
   end
 
+  describe '#undefined_props' do
+    let(:props) { { foo: 'foo', bar: 'bar', biz: 'biz', baz: 'baz' } }
+    let(:validator) do
+      React::Validator.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.build do
@@ -77,3 +122,4 @@ describe React::Validator do
     end
   end
 end
+end

data/spec/reactive-ruby/isomorphic_helpers_spec.rb

@@ -1,26 +1,43 @@
 require 'spec_helper'
 
 RSpec.describe React::IsomorphicHelpers do
-  describe 'code execution context', :ruby do
+  describe 'code execution context' do
     let(:klass) { Class.send(:include, described_class) }
-    describe 'module class methods' do
+
+    describe 'module class methods', :opal do
+      it { expect(described_class).to_not be_on_opal_server }
+      it { expect(described_class).to be_on_opal_client }
+    end
+
+    describe 'included class methods', :opal do
+      it { expect(klass).to_not be_on_opal_server }
+      it { expect(klass).to be_on_opal_client }
+    end
+
+    describe 'included instance methods', :opal do
+      it { expect(klass.new).to_not be_on_opal_server }
+      it { expect(klass.new).to be_on_opal_client }
+    end
+
+    describe 'module class methods', :ruby do
       it { is_expected.to_not be_on_opal_server }
       it { is_expected.to_not be_on_opal_client }
     end
 
-    describe 'included class methods' do
+    describe 'included class methods', :ruby do
       subject { klass }
       it { is_expected.to_not be_on_opal_server }
       it { is_expected.to_not be_on_opal_client }
     end
 
-    describe 'included instance methods' do
+    describe 'included instance methods', :ruby do
       subject { klass.new }
       it { is_expected.to_not be_on_opal_server }
       it { is_expected.to_not be_on_opal_client }
     end
   end
 
+if ruby?
   describe 'load_context', :ruby do
     let(:v8_context) { TestV8Context.new }
     let(:controller) { double('controller') }
@@ -135,3 +152,4 @@ RSpec.describe React::IsomorphicHelpers do
     end
   end
 end
+end

data/spec/spec_helper.rb

@@ -13,7 +13,58 @@ end
 
 if RUBY_ENGINE == 'opal'
   require 'reactive-ruby'
+  require File.expand_path('../support/react/spec_helpers', __FILE__)
+
+  module Opal
+    module RSpec
+      module AsyncHelpers
+        module ClassMethods
+          def rendering(title, &block)
+            klass = Class.new do
+              include React::Component
+
+              def self.block
+                @block
+              end
+
+              def self.name
+                "dummy class"
+              end
+
+              def render
+                instance_eval &self.class.block
+              end
+
+              def self.should_generate(opts={}, &block)
+                sself = self
+                @self.async(@title, opts) do
+                  expect_component_to_eventually(sself, &block)
+                end
+              end
+
+              def self.should_immediately_generate(opts={}, &block)
+                sself = self
+                @self.it(@title, opts) do
+                  element = build_element sself, {}
+                  context = block.arity > 0 ? self : element
+                  expect((element and context.instance_exec(element, &block))).to be(true)
+                end
+              end
+
+            end
+            klass.instance_variable_set("@block", block)
+            klass.instance_variable_set("@self", self)
+            klass.instance_variable_set("@title", "it can render #{title}")
+            klass
+          end
+        end
+      end
+    end
+  end
+
+
   RSpec.configure do |config|
+    config.include React::SpecHelpers
     config.filter_run_excluding :ruby
   end
 end