converting specs to new style param access

Author: catmando

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

@@ -83,7 +83,6 @@ def component_will_receive_props(next_props)
     def component_will_update(next_props, next_state)
       observing { run_callback(:before_update, next_props, next_state) }
       if @__hyperstack_component_receiving_props
-        params._reset_all_others_cache
         @__hyperstack_component_params_wrapper.reload(next_props)
       end
       @__hyperstack_component_receiving_props = false

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

@@ -12,6 +12,10 @@ def hyper_component?
           true
         end
 
+        def param_accessor_style(*args)
+          props_wrapper.param_accessor_style(*args)
+        end
+
         def backtrace(*args)
           @__hyperstack_component_dont_catch_exceptions = (args[0] == :none)
           @__hyperstack_component_backtrace_off = @__hyperstack_component_dont_catch_exceptions || (args[0] == :off)

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

@@ -9,6 +9,14 @@ def children
         end
 
         def params
+          if @__hyperstack_component_params_wrapper.param_accessor_style == :hyperstack
+            debugger
+            raise "params are now directly accessible via instance variables.\n"\
+                  '  to access the legacy behavior add `param_accessor_style = :legacy` '\
+                    "to your component class\n"\
+                  '  to access both behaviors add `param_accessor_style = :both` '\
+                    'to your component class'
+          end
           @__hyperstack_component_params_wrapper
         end
 

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

@@ -4,56 +4,70 @@ module Component
       class PropsWrapper
         attr_reader :component
 
-        def self.param_definitions
-          @param_definitions ||=
-            if superclass.respond_to? :param_definitions
-              superclass.param_definitions.dup
+        class << self
+
+          def param_accessor_style(*args)
+            @param_accessor_style = args[0] if args.length > 0
+            @param_accessor_style ||=
+              if superclass.respond_to? :param_accessor_style
+                superclass.param_accessor_style
+              else
+                :hyperstack
+              end
+          end
+
+          def param_definitions
+            @param_definitions ||=
+              if superclass.respond_to? :param_definitions
+                superclass.param_definitions.dup
+              else
+                Hash.new
+              end
+          end
+
+          def define_param(name, param_type, aka = nil)
+            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(aka.to_sym) do |*args, &block|
+                props[name].call(*args, &block) if props[name]
+              end
             else
-              Hash.new
+              define_method(aka.to_sym) do
+                fetch_from_cache(name, param_type, props)
+              end
             end
-        end
+          end
 
-        def self.define_param(name, param_type, aka = nil)
-          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(aka.to_sym) do |*args, &block|
-              props[name].call(*args, &block) if props[name]
-            end
-          else
-            define_method(aka.to_sym) do
-              fetch_from_cache(name, param_type, props)
+          def define_all_others(name)
+            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
+              @_all_others_cache ||= yield(props)
             end
           end
         end
 
-        def self.define_all_others(name)
-          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
+        def param_accessor_style
+          self.class.param_accessor_style
         end
 
         def initialize(component, incoming = nil)
           @component = component
+          return if self.class.param_accessor_style == :legacy
           self.class.param_definitions.each_value do |initializer|
             instance_exec(incoming || props, &initializer)
           end
         end
 
         def reload(next_props)
+          @_all_others_cache = nil # needed for legacy params wrapper
           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, param_type, props)

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

@@ -23,11 +23,11 @@ def render
         def top_level_render
           paths_searched = []
           component = nil
-          if params.component_name.start_with?('::')
+          if @component_name.start_with?('::')
             # if absolute path of component is given, look it up and fail if not found
-            paths_searched << params.component_name
+            paths_searched << @component_name
             component = begin
-                          Object.const_get(params.component_name)
+                          Object.const_get(@component_name)
                         rescue NameError
                           nil
                         end
@@ -40,28 +40,28 @@ def top_level_render
             # ::Foo::Bar will only resolve to some component named ::Foo::Bar
             # but Foo::Bar will check (in this order) ::Home::Foo::Bar, ::Components::Home::Foo::Bar, ::Foo::Bar, ::Components::Foo::Bar
             self.class.search_path.each do |scope|
-              paths_searched << "#{scope.name}::#{params.controller}::#{params.component_name}"
+              paths_searched << "#{scope.name}::#{@controller}::#{@component_name}"
               component = begin
-                            scope.const_get(params.controller, false).const_get(params.component_name, false)
+                            scope.const_get(@controller, false).const_get(@component_name, false)
                           rescue NameError
                             nil
                           end
               break if component != nil
             end
             unless component
               self.class.search_path.each do |scope|
-                paths_searched << "#{scope.name}::#{params.component_name}"
+                paths_searched << "#{scope.name}::#{@component_name}"
                 component = begin
-                              scope.const_get(params.component_name, false)
+                              scope.const_get(@component_name, false)
                             rescue NameError
                               nil
                             end
                 break if component != nil
               end
             end
           end
-          return RenderingContext.render(component, params.render_params) if component && component.method_defined?(:render)
-          raise "Could not find component class '#{params.component_name}' for params.controller '#{params.controller}' in any component directory. Tried [#{paths_searched.join(", ")}]"
+          return RenderingContext.render(component, @render_params) if component && component.method_defined?(:render)
+          raise "Could not find component class '#{@component_name}' for @controller '#{@controller}' in any component directory. Tried [#{paths_searched.join(", ")}]"
         end
       end
     end