added new style params are instance variables

Author: catmando

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

@@ -63,7 +63,7 @@ def component_will_mount
       IsomorphicHelpers.load_context(true) if IsomorphicHelpers.on_opal_client?
       observing(immediate_update: true) do
         Hyperstack::Internal::Component.mounted_components << self
-        run_callback(:before_mount)
+        run_callback(:before_mount, props)
       end
     end
 
@@ -74,7 +74,6 @@ 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) }
@@ -83,7 +82,10 @@ def component_will_receive_props(next_props)
 
     def component_will_update(next_props, next_state)
       observing { run_callback(:before_update, next_props, next_state) }
-      params._reset_all_others_cache if @__hyperstack_component_receiving_props
+      if @__hyperstack_component_receiving_props
+        params._reset_all_others_cache
+        @__hyperstack_component_params_wrapper.reload(next_props)
+      end
       @__hyperstack_component_receiving_props = false
     end
 

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

@@ -121,6 +121,13 @@ def collect_other_params_as(name)
         alias other_params collect_other_params_as
         alias others collect_other_params_as
 
+        def raises(name, opts = {})
+          aka = opts[:alias] || "#{name}!"
+          name = name =~ /^<(.+)>$/ ? name.gsub(/^<(.+)>$/, '\1') : "on_#{name}"
+          validator.event(name)
+          define_method(aka) { props[name]&.call }
+        end
+
         def define_state(*states, &block)
           deprecation_warning "'define_state' is deprecated. Use the 'state' macro to declare states."
           default_initial_value = (block && block.arity == 0) ? yield : nil

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

@@ -5,88 +5,78 @@ class PropsWrapper
         attr_reader :component
 
         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
+          @param_definitions ||=
+            if superclass.respond_to? :param_definitions
+              superclass.param_definitions.dup
+            else
+              Hash.new
+            end
         end
 
         def self.define_param(name, param_type, aka = nil)
-          param_definitions[name] = [param_type, aka || name]
+          aka ||= name
+          param_definitions[name] = ->(props) { @component.instance_variable_set :"@#{aka}", fetch_from_cache(name, param_type, props) } #[param_type, aka || name]
           if param_type == Proc
-            define_method("#{name}") do |*args, &block|
+            define_method(aka.to_sym) do |*args, &block|
               props[name].call(*args, &block) if props[name]
             end
           else
-            define_method("#{name}") do
-              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
-              end
+            define_method(aka.to_sym) do
+              fetch_from_cache(name, param_type, props)
             end
           end
         end
 
         def self.define_all_others(name)
-          define_method("#{name}") do
+          param_definitions[name] = -> (props) { puts "setting @#{name} props = #{props} self = #{self}"; @component.instance_variable_set :"@#{name}", yield(props) } #[:__hyperstack_component_all_others_flag, name, block]
+          define_method(name.to_sym) do
+            puts "calling good ole params.#{name} props = #{props} self = #{self}"
             @_all_others_cache ||= yield(props)
           end
         end
 
-
-        def initialize(component)
+        def initialize(component, incoming = nil)
           @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
+          self.class.param_definitions.each_value do |initializer|
+            instance_exec(incoming || props, &initializer)
           end
         end
 
-        def reload
-          initialize(@component)
+        def reload(next_props)
+          initialize(@component, next_props)
         end
 
         def [](prop)
           props[prop]
         end
 
-
         def _reset_all_others_cache
           @_all_others_cache = nil
         end
 
         private
 
-        def fetch_from_cache(name)
-          last, value = cache[name]
-          return value if last.equal?(props[name])
-          yield.tap do |value|
+        def fetch_from_cache(name, param_type, props)
+          last, cached_value = cache[name]
+          return cached_value if last.equal?(props[name])
+          convert_param(name, param_type).tap do |value|
             cache[name] = [props[name], value]
           end
         end
 
+        def convert_param(name, param_type)
+          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
+        end
+
         def cache
           @cache ||= Hash.new { |h, k| h[k] = [] }
         end
@@ -96,7 +86,7 @@ def props
         end
 
         def value_for(name)
-          self[name].instance_variable_get("@value") if self[name]
+          self[name].instance_variable_get('@value') if self[name]
         end
       end
     end

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

@@ -38,6 +38,10 @@ def optional(name, options = {})
           define_rule(name, options)
         end
 
+        def event(name)
+          rules[name] = coerce_native_hash_values(default: nil)
+        end
+
         def all_other_params(name)
           @allow_undefined_props = true
           props_wrapper.define_all_others(name) { |props| props.reject { |name, value| rules[name] } }
@@ -77,7 +81,7 @@ def rules
 
         def define_rule(name, options = {})
           rules[name] = coerce_native_hash_values(options)
-          props_wrapper.define_param(name, options[:type])
+          props_wrapper.define_param(name, options[:type], options[:alias])
         end
 
         def errors