react.rb 0.0.1

data/spec/element_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+describe React::Element do
+  it "should bridge `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
+    element = React.create_element('span')
+    div = `document.createElement("div")`
+    React.render(element, div) do
+      run_async {
+        expect(`div.children[0].tagName`).to eq("SPAN")
+      }
+    end
+  end
+
+  describe "Event subscription" do
+    it "should be subscribable through `on(:event_name)` method" do
+      expect { |b|
+        element = React.create_element("div").on(:click, &b)
+        instance = renderElementToDocument(element)
+        simulateEvent(:click, instance)
+      }.to yield_with_args(React::Event)
+
+      expect { |b|
+        element = React.create_element("div").on(:key_down, &b)
+        instance = renderElementToDocument(element)
+        simulateEvent(:keyDown, instance, {key: "Enter"})
+      }.to yield_control
+
+      expect { |b|
+        element = React.create_element("form").on(:submit, &b)
+        instance = renderElementToDocument(element)
+        simulateEvent(:submit, instance, {})
+      }.to yield_control
+    end
+
+    it "should return 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

data/spec/event_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+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|
+      expect(event.bubbles).to eq(`#{event.to_n}.bubbles`)
+      expect(event.cancelable).to eq(`#{event.to_n}.cancelable`)
+      expect(event.current_target).to eq(`#{event.to_n}.currentTarget`)
+      expect(event.default_prevented).to eq(`#{event.to_n}.defaultPrevented`)
+      expect(event.event_phase).to eq(`#{event.to_n}.eventPhase`)
+      expect(event.is_trusted?).to eq(`#{event.to_n}.isTrusted`)
+      expect(event.native_event).to eq(`#{event.to_n}.nativeEvent`)
+      expect(event.target).to eq(`#{event.to_n}.target`)
+      expect(event.timestamp).to eq(`#{event.to_n}.timeStamp`)
+      expect(event.event_type).to eq(`#{event.to_n}.type`)
+      expect(event).to respond_to(:prevent_default)
+      expect(event).to respond_to(:stop_propagation)
+    end
+    instance = renderElementToDocument(element)
+    simulateEvent(:click, instance)
+  end
+end

data/spec/react_spec.rb

@@ -0,0 +1,168 @@
+require "spec_helper"
+
+describe React 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)
+    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)
+    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)
+    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(element.props.children).to eq("lorem ipsum")
+      end
+
+      it "should create a valid element with children as array when block yield Array of element" 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(element.props.children.length).to eq(3)
+      end
+
+      it "should render element with children as array when block yield Array of element" do
+        element = React.create_element('div') do
+          [React.create_element('span'), React.create_element('span'), React.create_element('span')]
+        end
+        instance = renderElementToDocument(element)
+        expect(instance.getDOMNode.childNodes.length).to eq(3)
+      end
+    end
+    describe "custom element" do
+      before do
+        stub_const 'Foo', Class.new
+        Foo.class_eval do
+          def render
+            React.create_element("div") { "lorem" }
+          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")
+      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)
+      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)
+      end
+
+      it "should allow creating with properties" do
+        element = React.create_element(Foo, foo: "bar")
+        expect(element.props.foo).to eq("bar")
+      end
+
+      it "should raise error if provided class doesn't defined `render`" do
+        expect { React.create_element(Array) }.to raise_error
+      end
+    end
+
+    describe "create element with properties" do
+      it "should enforce snake-cased property name" do
+        element = React.create_element("div", class_name: "foo")
+        expect(element.props.className).to eq("foo")
+      end
+
+      it "should allow custom property" do
+        element = React.create_element("div", foo: "bar")
+        expect(element.props.foo).to eq("bar")
+      end
+
+      it "should not camel-case custom property" do
+        element = React.create_element("div", foo_bar: "foo")
+        expect(element.props.foo_bar).to eq("foo")
+      end
+    end
+
+    describe "class_name helpers (React.addons.classSet)" do
+      it "should transform Hash provided to `class_name` props as string" do
+        classes = {foo: true, bar: false, lorem: true}
+        element = React.create_element("div", class_name: classes)
+
+        expect(element.props.className).to eq("foo lorem")
+      end
+
+      it "should not alter behavior when passing a string" do
+        element = React.create_element("div", class_name: "foo bar")
+
+        expect(element.props.className).to eq("foo bar")
+      end
+    end
+  end
+
+
+  describe "render" do
+    async "should render element to DOM" do
+      div = `document.createElement("div")`
+      React.render(React.create_element('span') { "lorem" }, div) do
+        run_async {
+          expect(`div.children[0].tagName`).to eq("SPAN")
+          expect(`div.textContent`).to eq("lorem")
+        }
+      end
+    end
+
+    it "should work without providing a block" do
+      div = `document.createElement("div")`
+      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)
+      end
+    end
+
+    pending "should return nil to prevent abstraction leakage" do
+      div = `document.createElement("div")`
+      expect {
+        React.render(React.create_element('span') { "lorem" }, div)
+      }.to be_nil
+    end
+  end
+
+  describe "render_to_string" do
+    it "should render a React.Element to string" do
+      ele = React.create_element('span') { "lorem" }
+      expect(React.render_to_string(ele)).to be_kind_of(String)
+    end
+  end
+
+  describe "unmount_component_at_node" do
+    async "should unmount component at node" do
+      div = `document.createElement("div")`
+      React.render(React.create_element('span') { "lorem" }, div ) do
+        run_async {
+          expect(React.unmount_component_at_node(div)).to eq(true)
+        }
+      end
+    end
+  end
+
+end

data/spec/reactjs/index.html.erb

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+<head>
+</head>
+<body>
+  <%= javascript_include_tag 'react-with-addons' %>
+  <%= javascript_include_tag @server.main %>
+  <div id="placeholder" style="display: none"></div>
+</body>
+</html>

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'react'
+
+module ReactTestHelpers
+  `var ReactTestUtils = React.addons.TestUtils`
+
+  def renderToDocument(type, options = {})
+    element = React.create_element(type, options)
+    return renderElementToDocument(element)
+  end
+
+  def renderElementToDocument(element)
+    instance = Native(`ReactTestUtils.renderIntoDocument(#{element.to_n})`)
+    instance.class.include(React::Component::API)
+    return instance
+  end
+
+  def simulateEvent(event, element, params = {})
+    simulator = Native(`ReactTestUtils.Simulate`)
+    simulator[event.to_s].call(`#{element.to_n}.getDOMNode()`, params)
+  end
+
+  def isElementOfType(element, type)
+    `React.addons.TestUtils.isElementOfType(#{element.to_n}, #{type.cached_component_class})`
+  end
+end
+
+RSpec.configure do |config|
+  config.include ReactTestHelpers
+end

data/spec/validator_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+
+describe React::Validator do
+  describe "validate" do
+    describe "Presence validation" do
+      it "should check if required props provided" do
+        validator = React::Validator.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.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.build 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([])
+      end
+
+      it "should check if passed value with wrong custom type" do
+        stub_const 'Bar', Class.new
+        validator = React::Validator.build 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: Bar.new})).to eq([])
+      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: [{},{},{}]})).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.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 "default_props" do
+    it "should return specified default values" do
+      validator = React::Validator.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

data/vendor/active_support/core_ext/array/extract_options.rb

@@ -0,0 +1,29 @@
+class Hash
+  # By default, only instances of Hash itself are extractable.
+  # Subclasses of Hash may implement this method and return
+  # true to declare themselves as extractable. If a Hash
+  # is extractable, Array#extract_options! pops it from
+  # the Array when it is the last element of the Array.
+  def extractable_options?
+    instance_of?(Hash)
+  end
+end
+
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)           # => {}
+  #   options(1, 2, :a => :b) # => {:a=>:b}
+  def extract_options!
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end
+end

data/vendor/active_support/core_ext/class/attribute.rb

@@ -0,0 +1,127 @@
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/array/extract_options'
+
+class Class
+  # Declare a class-level attribute whose value is inheritable by subclasses.
+  # Subclasses can change their own value and it will not impact parent class.
+  #
+  #   class Base
+  #     class_attribute :setting
+  #   end
+  #
+  #   class Subclass < Base
+  #   end
+  #
+  #   Base.setting = true
+  #   Subclass.setting            # => true
+  #   Subclass.setting = false
+  #   Subclass.setting            # => false
+  #   Base.setting                # => true
+  #
+  # In the above case as long as Subclass does not assign a value to setting
+  # by performing <tt>Subclass.setting = _something_ </tt>, <tt>Subclass.setting</tt>
+  # would read value assigned to parent class. Once Subclass assigns a value then
+  # the value assigned by Subclass would be returned.
+  #
+  # This matches normal Ruby method inheritance: think of writing an attribute
+  # on a subclass as overriding the reader method. However, you need to be aware
+  # when using +class_attribute+ with mutable structures as +Array+ or +Hash+.
+  # In such cases, you don't want to do changes in places but use setters:
+  #
+  #   Base.setting = []
+  #   Base.setting                # => []
+  #   Subclass.setting            # => []
+  #
+  #   # Appending in child changes both parent and child because it is the same object:
+  #   Subclass.setting << :foo
+  #   Base.setting               # => [:foo]
+  #   Subclass.setting           # => [:foo]
+  #
+  #   # Use setters to not propagate changes:
+  #   Base.setting = []
+  #   Subclass.setting += [:foo]
+  #   Base.setting               # => []
+  #   Subclass.setting           # => [:foo]
+  #
+  # For convenience, an instance predicate method is defined as well.
+  # To skip it, pass <tt>instance_predicate: false</tt>.
+  #
+  #   Subclass.setting?       # => false
+  #
+  # Instances may overwrite the class value in the same way:
+  #
+  #   Base.setting = true
+  #   object = Base.new
+  #   object.setting          # => true
+  #   object.setting = false
+  #   object.setting          # => false
+  #   Base.setting            # => true
+  #
+  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+  #
+  #   object.setting          # => NoMethodError
+  #   object.setting?         # => NoMethodError
+  #
+  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
+  #
+  #   object.setting = false  # => NoMethodError
+  #
+  # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
+  def class_attribute(*attrs)
+    options = attrs.extract_options!
+    instance_reader = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
+    instance_writer = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
+    instance_predicate = options.fetch(:instance_predicate, true)
+
+    attrs.each do |name|
+      define_singleton_method(name) { nil }
+      define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
+
+      ivar = "@#{name}"
+
+      define_singleton_method("#{name}=") do |val|
+        singleton_class.class_eval do
+          remove_possible_method(name)
+          define_method(name) { val }
+        end
+
+        if singleton_class?
+          class_eval do
+            remove_possible_method(name)
+            define_method(name) do
+              if instance_variable_defined? ivar
+                instance_variable_get ivar
+              else
+                singleton_class.send name
+              end
+            end
+          end
+        end
+        val
+      end
+
+      if instance_reader
+        remove_possible_method name
+        define_method(name) do
+          if instance_variable_defined?(ivar)
+            instance_variable_get ivar
+          else
+            self.class.public_send name
+          end
+        end
+        define_method("#{name}?") { !!public_send(name) } if instance_predicate
+      end
+
+      attr_writer name if instance_writer
+    end
+  end
+
+  private
+
+    unless respond_to?(:singleton_class?)
+      def singleton_class?
+        ancestors.first != self
+      end
+    end
+end