rename all component instance variables to begin with __...

Author: catmando

ruby/hyper-component/lib/hyperstack/component.rb

@@ -47,7 +47,7 @@ def deprecation_warning(message)
     end
 
     def initialize(native_element)
-      @native = native_element
+      @__hyperstack_component_native = native_element
     end
 
     def emit(event_name, *args)
@@ -59,6 +59,7 @@ def emit(event_name, *args)
     end
 
     def component_will_mount
+      @__hyperstack_component_params_wrapper = self.class.props_wrapper.new(self)
       IsomorphicHelpers.load_context(true) if IsomorphicHelpers.on_opal_client?
       observing(immediate_update: true) do
         Hyperstack::Internal::Component.mounted_components << self
@@ -73,6 +74,7 @@ def component_did_mount
     end
 
     def component_will_receive_props(next_props)
+      @__hyperstack_component_params_wrapper.reload
       # 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
       observing(immediate_update: true) { run_callback(:before_receive_props, next_props) }
@@ -101,8 +103,6 @@ def component_did_catch(error, info)
       observing { run_callback(:after_error, error, info) }
     end
 
-    attr_reader :waiting_on_resources
-
     def mutations(_objects)
       # if we have to we may have to require that all objects respond to a "name" method (see legacy method update_react_js_state below)
       set_state('***_state_updated_at-***' => `Date.now() + Math.random()`)
@@ -128,10 +128,14 @@ def render
       raise 'no render defined'
     end unless method_defined?(:render)
 
+    def waiting_on_resources
+      @__hyperstack_component_waiting_on_resources
+    end
+
     def _render_wrapper
       observing(rendering: true) do
         element = Hyperstack::Internal::Component::RenderingContext.render(nil) { render || '' }
-        @waiting_on_resources =
+        @__hyperstack_component_waiting_on_resources =
           element.waiting_on_resources if element.respond_to? :waiting_on_resources
         element
       end

ruby/hyper-component/lib/hyperstack/component/native_library.rb

@@ -15,7 +15,7 @@ module Component
     class NativeLibrary
       class << self
         def imports(native_name)
-          @native_prefix = "#{native_name}."
+          @__hyperstack_component_native_prefix = "#{native_name}."
           self
         end
 
@@ -66,7 +66,7 @@ def lookup_native_name(js_name)
         end
 
         def scope_native_name(js_name)
-          "#{@native_prefix}#{js_name}"
+          "#{@__hyperstack_component_native_prefix}#{js_name}"
         end
 
         def create_component_wrapper(klass, native_name, ruby_name)

ruby/hyper-component/lib/hyperstack/internal/component.rb

@@ -8,7 +8,7 @@ module Internal
     module Component
       class << self
         def mounted_components
-          @mounted_components ||= Set.new
+          @__hyperstack_component_mounted_components ||= Set.new
         end
       end
     end

ruby/hyper-component/lib/hyperstack/internal/component/instance_methods.rb

@@ -5,31 +5,31 @@ module Internal
     module Component
       module InstanceMethods
         def children
-          Hyperstack::Component::Children.new(`#{@native}.props.children`)
+          Hyperstack::Component::Children.new(`#{@__hyperstack_component_native}.props.children`)
         end
 
         def params
-          @params ||= self.class.props_wrapper.new(self)
+          @__hyperstack_component_params_wrapper
         end
 
         def props
-          Hash.new(`#{@native}.props`)
+          Hash.new(`#{@__hyperstack_component_native}.props`)
         end
 
         def refs
-          Hash.new(`#{@native}.refs`)
+          Hash.new(`#{@__hyperstack_component_native}.refs`)
         end
 
         def dom_node
-          `ReactDOM.findDOMNode(#{self}.native)` # react >= v0.15.0
+          `ReactDOM.findDOMNode(#{self}.__hyperstack_component_native)` # react >= v0.15.0
         end
 
         def mounted?
           `(#{self}.is_mounted === undefined) ? false : #{self}.is_mounted`
         end
 
         def force_update!
-          `#{self}.native.forceUpdate()`
+          `#{self}.__hyperstack_component_native.forceUpdate()`
           self
         end
 
@@ -39,40 +39,40 @@ def set_state(state, &block)
 
         def set_state!(state, &block)
           set_or_replace_state_or_prop(state, 'setState', &block)
-          `#{self}.native.forceUpdate()`
+          `#{self}.__hyperstack_component_native.forceUpdate()`
         end
 
         private
 
         def set_or_replace_state_or_prop(state_or_prop, method, &block)
-          raise "No native ReactComponent associated" unless @native
+          raise "No native ReactComponent associated" unless @__hyperstack_component_native
           `var state_prop_n = #{state_or_prop.shallow_to_n}`
           # the state object is initalized when the ruby component is instantiated
-          # this is detected by self.native.__opalInstanceInitializedState
+          # this is detected by self.__hyperstack_component_native.__opalInstanceInitializedState
           # which is set in the native component constructor in ReactWrapper
           # the setState update callback is not called when initalizing initial state
           if block
             %x{
-              if (#{@native}.__opalInstanceInitializedState === true) {
-                #{@native}[method](state_prop_n, function(){
+              if (#{@__hyperstack_component_native}.__opalInstanceInitializedState === true) {
+                #{@__hyperstack_component_native}[method](state_prop_n, function(){
                   block.$call();
                 });
               } else {
                 for (var sp in state_prop_n) {
                   if (state_prop_n.hasOwnProperty(sp)) {
-                    #{@native}.state[sp] = state_prop_n[sp];
+                    #{@__hyperstack_component_native}.state[sp] = state_prop_n[sp];
                   }
                 }
               }
             }
           else
             %x{
-              if (#{@native}.__opalInstanceInitializedState === true) {
-                #{@native}[method](state_prop_n);
+              if (#{@__hyperstack_component_native}.__opalInstanceInitializedState === true) {
+                #{@__hyperstack_component_native}[method](state_prop_n);
               } else {
                 for (var sp in state_prop_n) {
                   if (state_prop_n.hasOwnProperty(sp)) {
-                    #{@native}.state[sp] = state_prop_n[sp];
+                    #{@__hyperstack_component_native}.state[sp] = state_prop_n[sp];
                   }
                 }
               }

ruby/hyper-component/lib/hyperstack/internal/component/props_wrapper.rb

@@ -1,11 +1,20 @@
 module Hyperstack
   module Internal
     module Component
-
       class PropsWrapper
         attr_reader :component
 
-        def self.define_param(name, param_type)
+        def self.param_definitions
+          @param_definitions if @param_definitions
+          if superclass.respond_to? :param_definitions
+            @param_definitions = superclass.param_definitions.dup
+          else
+            @param_definitions = Hash.new
+          end
+        end
+
+        def self.define_param(name, param_type, aka = nil)
+          param_definitions[name] = [param_type, aka || name]
           if param_type == Proc
             define_method("#{name}") do |*args, &block|
               props[name].call(*args, &block) if props[name]
@@ -37,6 +46,26 @@ def self.define_all_others(name)
 
         def initialize(component)
           @component = component
+          self.class.param_definitions.each do |name, memo|
+            param_type, aka = memo
+            val = fetch_from_cache(name) do
+                    if param_type.respond_to? :_react_param_conversion
+                      param_type._react_param_conversion props[name], nil
+                    elsif param_type.is_a?(Array) &&
+                      param_type[0].respond_to?(:_react_param_conversion)
+                      props[name].collect do |param|
+                        param_type[0]._react_param_conversion param, nil
+                      end
+                    else
+                      props[name]
+                    end
+              @component.instance_variable_set(:"@#{aka}", val)
+            end
+          end
+        end
+
+        def reload
+          initialize(@component)
         end
 
         def [](prop)

ruby/hyper-component/lib/hyperstack/internal/component/should_component_update.rb

@@ -70,7 +70,7 @@ def call_needs_update(next_params, next_state)
         def native_state_changed?(next_state_hash)
           # next_state = next_state_hash.to_n
           # %x{
-          #   var current_state = #{@native}.state
+          #   var current_state = #{@__hyperstack_component_native}.state
           #   var normalized_next_state =
           #     !next_state || Object.keys(next_state).length === 0 ? false : next_state
           #   var normalized_current_state =
@@ -84,15 +84,15 @@ def native_state_changed?(next_state_hash)
           #   return (normalized_current_state['***_state_updated_at-***'] !=
           #           normalized_next_state['***_state_updated_at-***'])
           # }
-          state_hash = Hash.new(`#{@native}.state`)
+          state_hash = Hash.new(`#{@__hyperstack_component_native}.state`)
           next_state_hash != state_hash
         end
         # rubocop:enable Metrics/MethodLength
 
         # Do a shallow compare on the two hashes. Starting in 0.9 we will do a deep compare. ???
 
         def props_changed?(next_props)
-          props = Hash.new(`#{@native}.props`)
+          props = Hash.new(`#{@__hyperstack_component_native}.props`)
           next_props != props
         end
       end