working, adding nicer outer most rendering routines

Author: catmando

lib/rails-helpers/top_level_rails_component.rb

@@ -8,33 +8,33 @@ def self.search_path
 
     export_component
 
-    required_param :component_name
-    required_param :controller
-    required_param :render_params
+    param :component_name
+    param :controller
+    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, false) } rescue nil
-        return present component, render_params if component && component.method_defined?(:render)
+      if params.component_name.start_with? "::"
+        paths_searched << params.component_name.gsub(/^\:\:/,"")
+        component = params.component_name.gsub(/^\:\:/,"").split("::").inject(Module) { |scope, next_const| scope.const_get(next_const, false) } rescue nil
+        return present component, params.render_params if component && 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, false) } rescue nil
-          return present component, render_params if component && component.method_defined?(:render)
+          # try each path + params.controller + params.component_name
+          paths_searched << "#{path.name + '::' unless path == Module}#{params.controller}::#{params.component_name}"
+          component = "#{params.controller}::#{params.component_name}".split("::").inject(path) { |scope, next_const| scope.const_get(next_const, false) } rescue nil
+          return present component, params.render_params if component && 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, false) } rescue nil
-          return present component, render_params if component && component.method_defined?(:render)
+          # then try each path + params.component_name
+          paths_searched << "#{path.name + '::' unless path == Module}#{params.component_name}"
+          component = "#{params.component_name}".split("::").inject(path) { |scope, next_const| scope.const_get(next_const, false) } rescue nil
+          return present component, params.render_params if component && 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(", ")}]"
+      raise "Could not find component class '#{params.component_name}' for params.controller '#{params.controller}' in any component directory. Tried [#{paths_searched.join(", ")}]"
     end
   end
 end

lib/react/callbacks.rb

@@ -7,9 +7,7 @@ def self.included(base)
     end
 
     def run_callback(name, *args)
-      attribute_name = "_#{name}_callbacks"
-      callbacks = self.class.send(attribute_name)
-      callbacks.each do |callback|
+      self.class.callbacks_for(name).each do |callback|
         if callback.is_a?(Proc)
           instance_exec(*args, &callback)
         else
@@ -30,6 +28,15 @@ def define_callback(callback_name)
           self.send("#{attribute_name}=", callbacks)
         end
       end
+
+      def callbacks_for(callback_name)
+        attribute_name = "_#{callback_name}_callbacks"
+        if superclass.respond_to? :callbacks_for
+          superclass.callbacks_for(callback_name)
+        else
+          []
+        end + self.send(attribute_name)
+      end
     end
   end
 end

lib/react/component.rb

@@ -14,6 +14,21 @@ module Component
     def self.included(base)
       base.include(API)
       base.include(React::Callbacks)
+      base.instance_eval do
+        class PropsWrapper
+
+          def initialize(props_hash)
+            @props_hash = props_hash
+            @processed_params = {}
+          end
+
+          def [](prop)
+            return unless @props_hash
+            @props_hash[prop]
+          end
+
+        end
+      end
       base.class_eval do
         class_attribute :initial_state
         define_callback :before_mount
@@ -23,6 +38,12 @@ def self.included(base)
         define_callback :after_update
         define_callback :before_unmount
 
+        def deprecated_params_method(name, *args, &block)
+          puts "deprecated_params_method for #{self.class.name}.#{name}"
+          # TODO display deprecation message, but only once per access to a method
+          params.send(name, *args, &block)
+        end
+
         def render
           raise "no render defined"
         end unless method_defined?(:render)
@@ -97,6 +118,11 @@ def initialize(native_element)
     end
 
     def params
+      @props_wrapper
+      #Hash.new(`#{@native}.props`)
+    end
+
+    def props
       Hash.new(`#{@native}.props`)
     end
 
@@ -105,8 +131,8 @@ def refs
     end
 
     def state
-      raise "No native ReactComponent associated" unless @native
-      Hash.new(`#{@native}.state`)
+      #raise "No native ReactComponent associated" unless @native
+      @state_wrapper ||= StateWrapper.new(@native, self)
     end
 
     def update_react_js_state(object, name, value)
@@ -123,7 +149,7 @@ def emit(event_name, *args)
 
     def component_will_mount
       IsomorphicHelpers.load_context(true) if IsomorphicHelpers.on_opal_client?
-      @processed_params = {}
+      @props_wrapper = self.class.const_get("PropsWrapper").new(Hash.new(`#{@native}.props`))
       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) }
@@ -144,14 +170,13 @@ 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]}`}
+      return true unless props.keys.sort == next_props.keys.sort
+      props.detect { |k, v| `#{next_props[k]} != #{params[k]}`}
     end
 
     def should_component_update?(next_props, next_state)
@@ -177,6 +202,7 @@ def should_component_update?(next_props, next_state)
 
     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)) }
+      @props_wrapper = self.class.const_get("PropsWrapper").new(Hash.new(next_props))
     rescue Exception => e
       self.class.process_exception(e, self)
     end
@@ -220,7 +246,7 @@ def component?(name)
     end
 
     def method_missing(n, *args, &block)
-      return params[n] if params.key? n
+      return props[n] if props.key? n # TODO deprecate and remove - done so that params shadow tags, no longer needed
       name = n
       if name =~ /_as_node$/
         node_only = true

lib/react/component/base.rb

@@ -0,0 +1,9 @@
+module React
+  module Component
+    class Base
+      def self.inherited(child)
+        child.send(:include, React::Component)
+      end
+    end
+  end
+end

lib/react/component/class_methods.rb

@@ -19,7 +19,7 @@ def process_exception(e, component, reraise = nil)
       end
 
       def validator
-        @validator ||= React::Validator.new
+        @validator ||= React::Validator.new(self)
       end
 
       def prop_types
@@ -47,50 +47,71 @@ def params(&block)
       end
 
       def define_param_method(name, param_type)
+        wrapper = const_get("PropsWrapper")
         if param_type == React::Observable
-          (@two_way_params ||= []) << name
-          define_method("#{name}") do
-            params[name].instance_variable_get("@value") if params[name]
+          #(@two_way_params ||= []) << name
+          wrapper.define_method("#{name}") do
+            @props_hash[name].instance_variable_get("@value") if @props_hash[name]
           end
-          define_method("#{name}!") do |*args|
-            return unless params[name]
+          wrapper.define_method("#{name}!") do |*args|
+            return unless @props_hash[name]
             if args.count > 0
-              current_value = params[name].instance_variable_get("@value")
-              params[name].call args[0]
+              current_value = @props_hash[name].instance_variable_get("@value")
+              @props_hash[name].call args[0]
               current_value
             else
-              current_value = params[name].instance_variable_get("@value")
-              params[name].call current_value unless @dont_update_state rescue nil # rescue in case we in middle of render
-              params[name]
+              current_value = @props_hash[name].instance_variable_get("@value")
+              @props_hash[name].call current_value unless @dont_update_state rescue nil # rescue in case we in middle of render
+              @props_hash[name]
             end
           end
+          define_method("#{name}") { deprecated_params_method("#{name}") }
+          define_method("#{name}!") { |*args| deprecated_params_method("#{name}!", *args) }
         elsif param_type == Proc
-          define_method("#{name}") do |*args, &block|
-            params[name].call(*args, &block) if params[name]
+          wrapper.define_method("#{name}") do |*args, &block|
+            @props_hash[name].call(*args, &block) if @props_hash[name]
           end
+          define_method("#{name}") { deprecated_params_method("#{name}", *args, &block) }
         else
-          define_method("#{name}") do
+          wrapper.define_method("#{name}") do
             @processed_params[name] ||= if param_type.respond_to? :_react_param_conversion
-                                          param_type._react_param_conversion params[name]
+                                          param_type._react_param_conversion @props_hash[name]
                                         elsif param_type.is_a?(Array) && param_type[0].respond_to?(:_react_param_conversion)
-                                          params[name].collect { |param| param_type[0]._react_param_conversion param }
+                                          @props_hash[name].collect { |param| param_type[0]._react_param_conversion param }
                                         else
-                                          params[name]
+                                          @props_hash[name]
                                         end
           end
+          define_method("#{name}") { deprecated_params_method("#{name}") }
+        end
+      end
+
+      def param(*args)
+        if args[0].is_a? Hash
+          options = args[0]
+          name = options.first[0]
+          default = options.first[1]
+          options.delete(name)
+          options.merge!({default: default})
+        else
+          name = args[0]
+          options = args[1] || {}
+        end
+        if options[:default]
+          validator.optional(name, options)
+        else
+          validator.requires(name, options)
         end
       end
 
       def required_param(name, options = {})
         validator.requires(name, options)
-        define_param_method(name, options[:type])
       end
 
       alias_method :require_param, :required_param
 
       def optional_param(name, options = {})
         validator.optional(name, options)
-        define_param_method(name, options[:type]) unless name == :params
       end
 
       def collect_other_params_as(name)
@@ -130,7 +151,6 @@ def define_state_methods(this, name, from = nil, &block)
           React::State.set_state(from || self, name, new_state)
         end
         this.define_method("#{name}!") do |*args|
-          #return unless @native
           if args.count > 0
             yield name, React::State.get_state(from || self, name), args[0] if block && block.arity > 0
             current_value = React::State.get_state(from || self, name)

lib/react/state.rb

@@ -1,4 +1,39 @@
 module React
+  class StateWrapper
+
+    def initialize(native, from)
+      @state_hash = Hash.new(`#{native}.state`)
+      @from = from
+    end
+
+    def [](state)
+      @state_hash[state]
+    end
+
+    def []=(state, new_value)
+      @state_hash[state] = new_value
+    end
+
+    def method_missing(method, *args)
+      if match = method.match(/^(.+)\!$/)
+        if args.count > 0
+          current_value = React::State.get_state(@from, match[1])
+          React::State.set_state(@from, $1, args[0])
+          current_value
+        else
+          current_state = React::State.get_state(@from, match[1])
+          React::State.set_state(@from, $1, current_state)
+          React::Observable.new(current_state) do |update|
+            React::State.set_state(@from, $1, update)
+          end
+        end
+      else
+        React::State.get_state(@from, method)
+      end
+    end
+  end
+
+
   class State
     class << self
       attr_reader :current_observer
@@ -80,14 +115,10 @@ def set_state_context_to(observer) # wrap all execution that may set or get stat
           @nesting_level = (@nesting_level || 0) + 1
           start_time = Time.now.to_f
           observer_name = (observer.class.respond_to?(:name) ? observer.class.name : observer.to_s) rescue "object:#{observer.object_id}"
-          puts "#{'  ' * @nesting_level} Timing #{observer_name} Execution"
         end
         saved_current_observer = @current_observer
         @current_observer = observer
         return_value = yield
-        if `typeof window.reactive_ruby_timing !== 'undefined'`
-          puts "#{'  ' * @nesting_level} Timing #{observer_name} Completed in #{'%.04f' % (Time.now.to_f-start_time)} seconds"
-        end
         return_value
       ensure
         @current_observer = saved_current_observer

lib/react/validator.rb

@@ -1,8 +1,13 @@
 module React
+
   class Validator
     attr_accessor :errors
     private :errors
 
+    def initialize(component_class)
+      @component_class = component_class
+    end
+
     def self.build(&block)
       self.new.build(&block)
     end
@@ -15,11 +20,13 @@ def build(&block)
     def requires(name, options = {})
       options[:required] = true
       define_rule(name, options)
+      @component_class.define_param_method(name, options[:type])
     end
 
     def optional(name, options = {})
       options[:required] = false
       define_rule(name, options)
+      @component_class.define_param_method(name, options[:type]) unless name == :params
     end
 
     def allow_undefined_props=(allow)
@@ -73,11 +80,14 @@ def errors
 
     def validate_types(prop_name, value)
       return unless klass = rules[prop_name][:type]
-      if klass.is_a?(Array) && klass.length > 0
+      if !klass.is_a?(Array)
+        allow_nil = !!rules[prop_name][:allow_nil]
+        type_check("`#{prop_name}`", value, klass, allow_nil)
+      elsif klass.length > 0
         validate_value_array(prop_name, value)
       else
         allow_nil = !!rules[prop_name][:allow_nil]
-        type_check("`#{prop_name}`", value, klass, allow_nil)
+        type_check("`#{prop_name}`", value, Array, allow_nil)
       end
     end