reactive-ruby 0.7.28 → 0.7.29

data/lib/rails-helpers/top_level_rails_component.rb

@@ -1,50 +1,45 @@
 module React
-  
   class TopLevelRailsComponent
-    
     include React::Component
-    
+
     def self.search_path
       @search_path ||= [Module]
     end
-    
+
     export_component
-    
+
     required_param :component_name
     required_param :controller
     required_param :render_params
-    
+
     backtrace :on
-    
+
     def render
       paths_searched = []
       if component_name.start_with? "::"
-        paths_searched << component_name.gsub("::","")
-        component = component_name.gsub("::","").split("::").inject(Module) { |scope, next_const| scope.const_get(next_const) } rescue nil
+        paths_searched << component_name.gsub(/^\:\:/,"")
+        component = component_name.gsub(/^\:\:/,"").split("::").inject(Module) { |scope, next_const| scope.const_get(next_const, false) } rescue nil
         return present component, render_params if component and component.method_defined? :render
       else
         self.class.search_path.each do |path|
           # try each path + controller + component_name
           paths_searched << "#{path.name + '::' unless path == Module}#{controller}::#{component_name}"
-          component = "#{controller}::#{component_name}".split("::").inject(path) { |scope, next_const| scope.const_get(next_const) } rescue nil
+          component = "#{controller}::#{component_name}".split("::").inject(path) { |scope, next_const| scope.const_get(next_const, false) } rescue nil
           return present component, render_params if component and component.method_defined? :render
         end
         self.class.search_path.each do |path|
           # then try each path + component_name
           paths_searched << "#{path.name + '::' unless path == Module}#{component_name}"
-          component = "#{component_name}".split("::").inject(path) { |scope, next_const| scope.const_get(next_const) } rescue nil
+          component = "#{component_name}".split("::").inject(path) { |scope, next_const| scope.const_get(next_const, false) } rescue nil
           return present component, render_params if component and component.method_defined? :render
         end
       end
       raise "Could not find component class '#{component_name}' for controller '#{controller}' in any component directory. Tried [#{paths_searched.join(", ")}]"
     end
-    
   end
-  
 end
 
 class Module
-  
   def add_to_react_search_path(replace_search_path = nil)
     if replace_search_path
       React::TopLevelRailsComponent.search_path = [self]
@@ -52,10 +47,8 @@ class Module
       React::TopLevelRailsComponent.search_path << self
     end
   end
-  
 end
 
 module Components
   add_to_react_search_path
 end
-  

data/lib/{reactive-ruby → react}/api.rb

@@ -1,77 +1,20 @@
-module React
+require 'react/native_library'
 
-  class NativeLibrary
-    
-    def self.renames_and_exclusions
-      @renames_and_exclusions ||= {}
-    end
-    
-    def self.libraries
-      @libraries ||= []
-    end
-    
-    def self.const_missing(name)
-      if renames_and_exclusions.has_key? name
-        if native_name = renames_and_exclusions[name]
-          native_name 
-        else
-          super
-        end
-      else
-        libraries.each do |library|
-          native_name = "#{library}.#{name}"
-          native_component = `eval(#{native_name})` rescue nil
-          React::API.import_native_component(name, native_component) and return name if native_component and `native_component != undefined`
-        end 
-        name
-      end
-    end
-    
-    def self.method_missing(n, *args, &block)
-      name = n
-      if name =~ /_as_node$/ 
-        node_only = true
-        name = name.gsub(/_as_node$/, "")
-      end
-      unless name = const_get(name) 
-        return super
-      end
-      if node_only
-        React::RenderingContext.build { React::RenderingContext.render(name, *args, &block) }.to_n
-      else
-        React::RenderingContext.render(name, *args, &block)
-      end
-    rescue 
-    end
-        
-    def self.imports(library)
-      libraries << library
-    end
-    
-    def self.rename(rename_list={})
-      renames_and_exclusions.merge!(rename_list.invert)
-    end
-    
-    def self.exclude(*exclude_list)
-      renames_and_exclusions.merge(Hash[exclude_list.map {|k| [k, nil]}])
-    end
-    
-  end
-  
+module React
   class API
-    
     @@component_classes = {}
-    
-    def self.import_native_component(opal_class, native_class)  
+
+    def self.import_native_component(opal_class, native_class)
       @@component_classes[opal_class.to_s] = native_class
-    end 
-    
+    end
+
     def self.create_native_react_class(type)
       raise "Provided class should define `render` method"  if !(type.method_defined? :render)
       render_fn = (type.method_defined? :_render_wrapper) ? :_render_wrapper : :render
       # this was hashing type.to_s, not sure why but .to_s does not work as it Foo::Bar::View.to_s just returns "View"
       @@component_classes[type] ||= %x{
         React.createClass({
+          displayName: #{type.name},
           propTypes: #{type.respond_to?(:prop_types) ? type.prop_types.to_n : `{}`},
           getDefaultProps: function(){
             return #{type.respond_to?(:default_props) ? type.default_props.to_n : `{}`};
@@ -154,7 +97,7 @@ module React
     def self.clear_component_class_cache
       @@component_classes = {}
     end
-    
+
     def self.convert_props(properties)
       raise "Component parameters must be a hash. Instead you sent #{properties}" unless properties.is_a? Hash
       props = {}

data/lib/react/component.rb

@@ -0,0 +1,266 @@
+require 'react/ext/string'
+require 'react/ext/hash'
+require 'active_support/core_ext/class/attribute'
+require 'react/callbacks'
+require 'react/rendering_context'
+require 'react/observable'
+require 'react/state'
+require 'react/component/api'
+require 'react/component/class_methods'
+require 'native'
+
+module React
+  module Component
+    def self.included(base)
+      base.include(API)
+      base.include(React::Callbacks)
+      base.class_eval do
+        class_attribute :initial_state
+        define_callback :before_mount
+        define_callback :after_mount
+        define_callback :before_receive_props
+        define_callback :before_update
+        define_callback :after_update
+        define_callback :before_unmount
+
+        def render
+          raise "no render defined"
+        end unless method_defined? :render
+
+        def children
+          nodes = [`#{@native}.props.children`].flatten
+          class << nodes
+            include Enumerable
+
+            def to_n
+              self
+            end
+
+            def each(&block)
+              if block_given?
+                %x{
+                  React.Children.forEach(#{self.to_n}, function(context){
+                    #{block.call(React::Element.new(`context`))}
+                  })
+                }
+                nil
+              else
+                Enumerator.new(`React.Children.count(#{self.to_n})`) do |y|
+                  %x{
+                    React.Children.forEach(#{self.to_n}, function(context){
+                      #{y << React::Element.new(`context`)}
+                    })
+                  }
+                end
+              end
+            end
+          end
+
+          nodes
+        end
+
+      end
+      base.extend(ClassMethods)
+
+      if base.name
+        parent = base.name.split("::").inject([Module]) { |nesting, next_const| nesting + [nesting.last.const_get(next_const)] }[-2]
+
+        class << parent
+
+          def method_missing(n, *args, &block)
+            name = n
+            if name =~ /_as_node$/
+              node_only = true
+              name = name.gsub(/_as_node$/, "")
+            end
+            begin
+              name = const_get(name)
+            rescue Exception
+              name = nil
+            end
+            unless name and name.method_defined? :render
+              return super
+            end
+            if node_only
+              React::RenderingContext.build { React::RenderingContext.render(name, *args, &block) }.to_n
+            else
+              React::RenderingContext.render(name, *args, &block)
+            end
+          end
+
+        end
+      end
+    end
+
+    def initialize(native_element)
+      @native = native_element
+    end
+
+    def params
+      Hash.new(`#{@native}.props`)
+    end
+
+    def refs
+      Hash.new(`#{@native}.refs`)
+    end
+
+    def state
+      raise "No native ReactComponent associated" unless @native
+      Hash.new(`#{@native}.state`)
+    end
+
+    def update_react_js_state(object, name, value)
+      if object
+        set_state({"***_state_updated_at-***" => Time.now.to_f, "#{object.class.to_s+'.' unless object == self}#{name}" => value})
+      else
+        set_state({name => value})
+      end rescue nil
+    end
+
+    def emit(event_name, *args)
+      self.params["_on#{event_name.to_s.event_camelize}"].call(*args)
+    end
+
+    def component_will_mount
+      IsomorphicHelpers.load_context(true) if IsomorphicHelpers.on_opal_client?
+      @processed_params = {}
+      set_state! initial_state if initial_state
+      React::State.initialize_states(self, initial_state)
+      React::State.set_state_context_to(self) { self.run_callback(:before_mount) }
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    end
+
+    def component_did_mount
+      React::State.set_state_context_to(self) do
+        self.run_callback(:after_mount)
+        React::State.update_states_to_observe
+      end
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    end
+
+    def component_will_receive_props(next_props)
+      # need to rethink how this works in opal-react, or if its actually that useful within the react.rb environment
+      # for now we are just using it to clear processed_params
+      React::State.set_state_context_to(self) { self.run_callback(:before_receive_props, Hash.new(next_props)) }
+      @processed_params = {}
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    end
+
+    def props_changed?(next_props)
+      return true unless params.keys.sort == next_props.keys.sort
+      params.detect { |k, v| `#{next_props[k]} != #{params[k]}`}
+    end
+
+    def should_component_update?(next_props, next_state)
+      React::State.set_state_context_to(self) do
+        next_props = Hash.new(next_props)
+        if self.respond_to?(:needs_update?)
+          !!self.needs_update?(next_props, Hash.new(next_state))
+        elsif false # switch to true to force updates per standard react
+          true
+        elsif props_changed? next_props
+          true
+        elsif `!next_state != !#{@native}.state`
+          true
+        elsif `!next_state && !#{@native}.state`
+          false
+        elsif `next_state["***_state_updated_at-***"] != #{@native}.state["***_state_updated_at-***"]`
+          true
+        else
+          false
+        end.to_n
+      end
+    end
+
+    def component_will_update(next_props, next_state)
+      React::State.set_state_context_to(self) { self.run_callback(:before_update, Hash.new(next_props), Hash.new(next_state)) }
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    end
+
+    def component_did_update(prev_props, prev_state)
+      React::State.set_state_context_to(self) do
+        self.run_callback(:after_update, Hash.new(prev_props), Hash.new(prev_state))
+        React::State.update_states_to_observe
+      end
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    end
+
+    def component_will_unmount
+      React::State.set_state_context_to(self) do
+        self.run_callback(:before_unmount)
+        React::State.remove
+      end
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    end
+
+    def p(*args, &block)
+      if block || args.count == 0 || (args.count == 1 && args.first.is_a?(Hash))
+        _p_tag(*args, &block)
+      else
+        Kernel.p(*args)
+      end
+    end
+
+    def component?(name)
+      name_list = name.split("::")
+      scope_list = self.class.name.split("::").inject([Module]) { |nesting, next_const| nesting + [nesting.last.const_get(next_const)] }.reverse
+      scope_list.each do |scope|
+        component = name_list.inject(scope) do |scope, class_name|
+          scope.const_get(class_name)
+        end rescue nil
+        return component if component and component.method_defined? :render
+      end
+      nil
+    end
+
+    def method_missing(n, *args, &block)
+      return params[n] if params.key? n
+      name = n
+      if name =~ /_as_node$/
+        node_only = true
+        name = name.gsub(/_as_node$/, "")
+      end
+      unless (React::HTML_TAGS.include?(name) || name == 'present'  || name == '_p_tag' || (name = component?(name, self)))
+        return super
+      end
+
+      if name == "present"
+        name = args.shift
+      end
+
+      if name == "_p_tag"
+        name = "p"
+      end
+
+      if node_only
+        React::RenderingContext.build { React::RenderingContext.render(name, *args, &block) }.to_n
+      else
+        React::RenderingContext.render(name, *args, &block)
+      end
+    end
+
+    def watch(value, &on_change)
+      React::Observable.new(value, on_change)
+    end
+
+    def define_state(*args, &block)
+      React::State.initialize_states(self, self.class.define_state(*args, &block))
+    end
+
+    attr_reader :waiting_on_resources
+
+    def _render_wrapper
+      React::State.set_state_context_to(self) do
+        RenderingContext.render(nil) {render || ""}.tap { |element| @waiting_on_resources = element.waiting_on_resources if element.respond_to? :waiting_on_resources }
+      end
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    end
+  end
+end

data/lib/react/component/api.rb

@@ -0,0 +1,48 @@
+module React
+  module Component
+    module API
+      def dom_node
+        if `typeof React.findDOMNode === 'undefined'`
+          `#{self}.native.getDOMNode`            # v0.12.0
+        else
+          `React.findDOMNode(#{self}.native)`    # v0.13.0
+        end
+      end
+
+      def mounted?
+        `#{self}.native.isMounted()`
+      end
+
+      def force_update!
+        `#{self}.native.forceUpdate()`
+      end
+
+      def set_props(prop, &block)
+        set_or_replace_state_or_prop(prop, 'setProps', &block)
+      end
+
+      def set_props!(prop, &block)
+        set_or_replace_state_or_prop(prop, 'replaceProps', &block)
+      end
+
+      def set_state(state, &block)
+        set_or_replace_state_or_prop(state, 'setState', &block)
+      end
+
+      def set_state!(state, &block)
+        set_or_replace_state_or_prop(state, 'replaceState', &block)
+      end
+
+      private
+
+      def set_or_replace_state_or_prop(state_or_prop, method, &block)
+        raise "No native ReactComponent associated" unless @native
+        %x{
+          #{@native}[#{method}](#{state_or_prop.shallow_to_n}, function(){
+            #{block.call if block}
+          });
+        }
+      end
+    end
+  end
+end