reactrb 0.8.8 → 0.9.0

data/lib/react/object.rb

@@ -0,0 +1,15 @@
+# Lazy load HTML tag constants in the form DIV or A
+# This is needed to allow for a HAML expression like this DIV.my_class
+class Object
+  class << self
+    alias _reactrb_tag_original_const_missing const_missing
+
+    def const_missing(const_name)
+      # Opal uses const_missing to initially define things,
+      # so we always call the original, and respond to the exception
+      _reactrb_tag_original_const_missing(const_name)
+    rescue StandardError => e
+      React::Component::Tags.html_tag_class_for(const_name) || raise(e)
+    end
+  end
+end

data/lib/react/react-source.rb

@@ -0,0 +1,9 @@
+if RUBY_ENGINE == 'opal'
+  require 'react.js'
+  require "react-server.js"
+else
+  require "react/rails/asset_variant"
+  react_directory = React::Rails::AssetVariant.new(addons: true).react_directory
+  Opal.append_path react_directory.untaint
+  Opal.append_path File.expand_path('../../react-sources/', __FILE__).untaint
+end

data/lib/react/rendering_context.rb

@@ -2,113 +2,117 @@ module React
   class RenderingContext
     class << self
       attr_accessor :waiting_on_resources
-    end
 
-    def self.build_only(name, *args, &block)
-      React::Component.deprecation_warning(
-        '..._as_node is deprecated.  Render component and then use the .node method instead'
-      )
-      React::RenderingContext.build { React::RenderingContext.render(name, *args, &block) }.to_n
-    end
+      def build_only(name, *args, &block)
+        React::Component.deprecation_warning(
+          '..._as_node is deprecated.  Render component and then use the .node method instead'
+        )
+        React::RenderingContext.build { React::RenderingContext.render(name, *args, &block) }.to_n
+      end
 
-    def self.render(name, *args, &block)
-      remove_nodes_from_args(args)
-      @buffer ||= [] unless @buffer
-      if block
-        element = build do
-          saved_waiting_on_resources = waiting_on_resources
-          self.waiting_on_resources = nil
-          run_child_block(name.nil?, &block)
-          if name
-            buffer = @buffer.dup
-            React.create_element(name, *args) { buffer }.tap do |element|
-              element.waiting_on_resources = saved_waiting_on_resources || !!buffer.detect { |e| e.waiting_on_resources if e.respond_to?(:waiting_on_resources) }
+      def render(name, *args, &block)
+        remove_nodes_from_args(args)
+        @buffer ||= [] unless @buffer
+        if block
+          element = build do
+            saved_waiting_on_resources = waiting_on_resources
+            self.waiting_on_resources = nil
+            run_child_block(name.nil?, &block)
+            if name
+              buffer = @buffer.dup
+              React.create_element(name, *args) { buffer }.tap do |element|
+                element.waiting_on_resources = saved_waiting_on_resources || !!buffer.detect { |e| e.waiting_on_resources if e.respond_to?(:waiting_on_resources) }
+              end
+            elsif @buffer.last.is_a? React::Element
+              @buffer.last.tap { |element| element.waiting_on_resources ||= saved_waiting_on_resources }
+            else
+              @buffer.last.to_s.span.tap { |element| element.waiting_on_resources = saved_waiting_on_resources }
             end
-          elsif @buffer.last.is_a? React::Element
-            @buffer.last.tap { |element| element.waiting_on_resources ||= saved_waiting_on_resources }
-          else
-            @buffer.last.to_s.span.tap { |element| element.waiting_on_resources = saved_waiting_on_resources }
           end
+        elsif name.is_a? React::Element
+          element = name
+        else
+          element = React.create_element(name, *args)
+          element.waiting_on_resources = waiting_on_resources
         end
-      elsif name.is_a? React::Element
-        element = name
-      else
-        element = React.create_element(name, *args)
-        element.waiting_on_resources = waiting_on_resources
+        @buffer << element
+        self.waiting_on_resources = nil
+        element
       end
-      @buffer << element
-      self.waiting_on_resources = nil
-      element
-    end
 
-    def self.build
-      current = @buffer
-      @buffer = []
-      return_val = yield @buffer
-      @buffer = current
-      return_val
-    end
+      def build
+        current = @buffer
+        @buffer = []
+        return_val = yield @buffer
+        @buffer = current
+        return_val
+      end
 
-    def self.as_node(element)
-      @buffer.delete(element)
-      element
-    end
+      def as_node(element)
+        @buffer.delete(element)
+        element
+      end
 
-    class << self; alias delete as_node; end
+      alias delete as_node
 
-    def self.replace(e1, e2)
-      @buffer[@buffer.index(e1)] = e2
-    end
+      def rendered?(element)
+        @buffer.include? element
+      end
 
-    def self.remove_nodes_from_args(args)
-      args[0].each do |key, value|
-        value.as_node if value.is_a?(Element) rescue nil
-      end if args[0] && args[0].is_a?(Hash)
-    end
+      def replace(e1, e2)
+        @buffer[@buffer.index(e1)] = e2
+      end
 
-    # run_child_block gathers the element(s) generated by a child block.
-    # for example when rendering this div: div { "hello".span; "goodby".span }
-    # two child Elements will be generated.
-    #
-    # the final value of the block should either be
-    #   1 an object that responds to :acts_as_string?
-    #   2 a string,
-    #   3 an element that is NOT yet pushed on the rendering buffer
-    #   4 or the last element pushed on the buffer
-    #
-    # in case 1 we change the object to a string, and then it becomes case 2
-    # in case 2 we automatically push the string onto the buffer
-    # in case 3 we also push the Element onto the buffer IF the buffer is empty
-    # case 4 requires no special processing
-    #
-    # Once we have taken care of these special cases we do a check IF we are in an
-    # outer rendering scope.  In this case react only allows us to generate 1 Element
-    # so we insure that is the case, and also check to make sure that element in the buffer
-    # is the element returned
-
-    def self.run_child_block(is_outer_scope)
-      result = yield
-      result = result.to_s if result.try :acts_as_string?
-      @buffer << result if result.is_a?(String) || (result.is_a?(Element) && @buffer.empty?)
-      raise_render_error(result) if is_outer_scope && @buffer != [result]
-    end
+      def remove_nodes_from_args(args)
+        args[0].each do |key, value|
+          value.as_node if value.is_a?(Element) rescue nil
+        end if args[0] && args[0].is_a?(Hash)
+      end
 
-    # heurestically raise a meaningful error based on the situation
-
-    def self.raise_render_error(result)
-      improper_render 'A different element was returned than was generated within the DSL.',
-                      'Possibly improper use of Element#delete.' if @buffer.count == 1
-      improper_render "Instead #{@buffer.count} elements were generated.",
-                      'Do you want to wrap your elements in a div?' if @buffer.count > 1
-      improper_render "Instead the component #{result} was returned.",
-                      "Did you mean #{result}()?" if result.try :reactrb_component?
-      improper_render "Instead the #{result.class} #{result} was returned.",
-                      'You may need to convert this to a string.'
-    end
+      # run_child_block gathers the element(s) generated by a child block.
+      # for example when rendering this div: div { "hello".span; "goodby".span }
+      # two child Elements will be generated.
+      #
+      # the final value of the block should either be
+      #   1 an object that responds to :acts_as_string?
+      #   2 a string,
+      #   3 an element that is NOT yet pushed on the rendering buffer
+      #   4 or the last element pushed on the buffer
+      #
+      # in case 1 we change the object to a string, and then it becomes case 2
+      # in case 2 we automatically push the string onto the buffer
+      # in case 3 we also push the Element onto the buffer IF the buffer is empty
+      # case 4 requires no special processing
+      #
+      # Once we have taken care of these special cases we do a check IF we are in an
+      # outer rendering scope.  In this case react only allows us to generate 1 Element
+      # so we insure that is the case, and also check to make sure that element in the buffer
+      # is the element returned
+
+      def run_child_block(is_outer_scope)
+        result = yield
+        result = result.to_s if result.try :acts_as_string?
+        @buffer << result if result.is_a?(String) || (result.is_a?(Element) && @buffer.empty?)
+        raise_render_error(result) if is_outer_scope && @buffer != [result]
+      end
+
+      # heurestically raise a meaningful error based on the situation
 
-    def self.improper_render(message, solution)
-      raise "a component's render method must generate and return exactly 1 element or a string.\n"\
-            "    #{message}  #{solution}"
+      def raise_render_error(result)
+        improper_render 'A different element was returned than was generated within the DSL.',
+                        'Possibly improper use of Element#delete.' if @buffer.count == 1
+        improper_render "Instead #{@buffer.count} elements were generated.",
+                        'Do you want to wrap your elements in a div?' if @buffer.count > 1
+        improper_render "Instead the component #{result} was returned.",
+                        "Did you mean #{result}()?" if result.try :reactrb_component?
+        improper_render "Instead the #{result.class} #{result} was returned.",
+                        'You may need to convert this to a string.'
+      end
+
+      def improper_render(message, solution)
+        raise "a component's render method must generate and return exactly 1 element or a string.\n"\
+              "    #{message}  #{solution}"
+      end
     end
   end
 

data/lib/react/state.rb

@@ -33,6 +33,9 @@ module React
   end
 
   class State
+
+    @rendering_level = 0
+
     class << self
       attr_reader :current_observer
 
@@ -41,12 +44,23 @@ module React
       end
 
       def get_state(object, name, current_observer = @current_observer)
-        # get current value of name for object, remember that the current object depends on this state, current observer can be overriden with last param
+        # get current value of name for object, remember that the current object depends on this state,
+        # current observer can be overriden with last param
         new_observers[current_observer][object] << name if current_observer && !new_observers[current_observer][object].include?(name)
         states[object][name]
       end
 
-      def set_state2(object, name, value)  # set object's name state to value, tell all observers it has changed.  Observers must implement update_react_js_state
+      def set_state(object, name, value, wait_till_thread_completes = nil)
+        states[object][name] = value
+        if wait_till_thread_completes
+          notify_observers_after_thread_completes(object, name, value)
+        elsif @rendering_level == 0
+          notify_observers(object, name, value)
+        end
+        value
+      end
+
+      def notify_observers(object, name, value)
         object_needs_notification = object.respond_to? :update_react_js_state
         observers_by_name[object][name].dup.each do |observer|
           observer.update_react_js_state(object, name, value)
@@ -55,23 +69,14 @@ module React
         object.update_react_js_state(nil, name, value) if object_needs_notification
       end
 
-      def set_state(object, name, value, delay=nil)
-        states[object][name] = value
-        if delay
-          @delayed_updates ||= []
-          @delayed_updates << [object, name, value]
-          @delayed_updater ||= after(0.001) do
-            delayed_updates = @delayed_updates
-            @delayed_updates = []
-            @delayed_updater = nil
-            delayed_updates.each do |object, name, value|
-              set_state2(object, name, value)
-            end
-          end
-        else
-          set_state2(object, name, value)
+      def notify_observers_after_thread_completes(object, name, value)
+        (@delayed_updates ||= []) << [object, name, value]
+        @delayed_updater ||= after(0) do
+          delayed_updates = @delayed_updates
+          @delayed_updates = []
+          @delayed_updater = nil
+          delayed_updates.each { |args| notify_observers(*args) }
         end
-        value
       end
 
       def will_be_observing?(object, name, current_observer)
@@ -108,7 +113,7 @@ module React
         current_observers.delete(@current_observer)
       end
 
-      def set_state_context_to(observer) # wrap all execution that may set or get states in a block so we know which observer is executing
+      def set_state_context_to(observer, rendering = nil) # wrap all execution that may set or get states in a block so we know which observer is executing
         if `typeof window.reactive_ruby_timing !== 'undefined'`
           @nesting_level = (@nesting_level || 0) + 1
           start_time = Time.now.to_f
@@ -116,10 +121,12 @@ module React
         end
         saved_current_observer = @current_observer
         @current_observer = observer
+        @rendering_level += 1 if rendering
         return_value = yield
         return_value
       ensure
         @current_observer = saved_current_observer
+        @rendering_level -= 1 if rendering
         @nesting_level = [0, @nesting_level - 1].max if `typeof window.reactive_ruby_timing !== 'undefined'`
         return_value
       end
@@ -130,11 +137,10 @@ module React
 
       [:new_observers, :current_observers, :observers_by_name].each do |method_name|
         define_method(method_name) do
-          instance_variable_get("@#{method_name}") or
+          instance_variable_get("@#{method_name}") ||
           instance_variable_set("@#{method_name}", Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = [] } })
         end
       end
-
     end
   end
 end

data/lib/react/test.rb

@@ -0,0 +1,16 @@
+require 'react/test/session'
+require 'react/test/dsl'
+
+module React
+  module Test
+    class << self
+      def current_session
+        @current_session ||= Session.new
+      end
+
+      def reset_session!
+        @current_session = nil
+      end
+    end
+  end
+end

data/lib/react/test/dsl.rb

@@ -0,0 +1,17 @@
+require 'react/test'
+
+module React
+  module Test
+    module DSL
+      def component
+        React::Test.current_session
+      end
+
+      Session::DSL_METHODS.each do |method|
+        define_method method do |*args, &block|
+          component.public_send(method, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/react/test/matchers/render_html_matcher.rb

@@ -0,0 +1,49 @@
+module React
+  module Test
+    module Matchers
+      class RenderHTMLMatcher
+        def initialize(expected)
+          @expected = expected
+          @params = {}
+        end
+
+        def with_params(params)
+          @params = params
+          self
+        end
+
+        def matches?(component)
+          @component = component
+          @actual = render_to_html
+          @expected == @actual
+        end
+
+        def failure_message
+          failure_string
+        end
+
+        def negative_failure_message
+          failure_string(:negative)
+        end
+
+        private
+
+        def render_to_html
+          element = React.create_element(@component, @params)
+          React.render_to_static_markup(element)
+        end
+
+        def failure_string(negative = false)
+          str = "expected '#{@component.name}' with params '#{@params}' to "
+          str = str + "not " if negative
+          str = str + "render '#{@expected}', but '#{@actual}' was rendered."
+          str
+        end
+      end
+
+      def render(*args)
+        RenderHTMLMatcher.new(*args)
+      end
+    end
+  end
+end

data/lib/react/test/rspec.rb

@@ -0,0 +1,15 @@
+require 'react/test/dsl'
+require 'react/test/matchers/render_html_matcher'
+
+RSpec.configure do |config|
+  config.include React::Test::DSL, type: :component
+  config.include React::Test::Matchers, type: :component
+
+  config.after do
+    React::Test.reset_session!
+  end
+
+  config.before do
+    # nothing yet
+  end
+end

data/lib/react/test/session.rb

@@ -0,0 +1,46 @@
+module React
+  module Test
+    class Session
+      DSL_METHODS = %i[mount instance native element update_params
+        force_update! html].freeze
+
+      def mount(component_klass, params = {})
+        @element = React.create_element(component_klass, params)
+        instance
+      end
+
+      def instance
+        unless @instance
+          @native = Native(`React.addons.TestUtils.renderIntoDocument(#{element.to_n})`)
+          @instance = `#{@native.to_n}._getOpalInstance()`
+        end
+        @instance
+      end
+
+      def native
+        @native
+      end
+
+      def element
+        @element
+      end
+
+      def update_params(params)
+        cloned_element = React::Element.new(`React.cloneElement(#{self.element.to_n}, #{params.to_n})`)
+        prev_container = `#{self.instance.dom_node}.parentNode`
+        React.render(cloned_element, prev_container)
+        nil
+      end
+
+      def force_update!
+        native.force_update!
+      end
+
+      def html
+        # How can we get the current ReactElement w/o violating private APIs?
+        elem = Native(native[:_reactInternalInstance][:_currentElement])
+        React.render_to_static_markup(elem)
+      end
+    end
+  end
+end