fixes #125

Author: catmando

lib/react/component.rb

@@ -179,7 +179,7 @@ def should_component_update?(next_props, next_state)
 
     def component_will_update(next_props, next_state)
       State.set_state_context_to(self) { self.run_callback(:before_update, Hash.new(next_props), Hash.new(next_state)) }
-      @props_wrapper = self.class.props_wrapper.new(Hash.new(next_props))
+      @props_wrapper = self.class.props_wrapper.new(Hash.new(next_props), @props_wrapper)
     rescue Exception => e
       self.class.process_exception(e, self)
     end

lib/react/component/props_wrapper.rb

@@ -33,23 +33,39 @@ def self.define_param(name, param_type, owner)
           end
         else
           define_method("#{name}") do
-            @processed_params[name] ||= if param_type.respond_to? :_react_param_conversion
-              param_type._react_param_conversion props[name]
-            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
-              end
+            if @processed_params.has_key? name
+              @processed_params[name]
             else
-              props[name]
+              @processed_params[name] = if param_type.respond_to? :_react_param_conversion
+                param_type._react_param_conversion props[name]
+              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
+                end
+              else
+                props[name]
+              end
             end
           end
         end
       end
 
-      def initialize(props)
+      def unchanged_processed_params(new_props)
+        Hash[
+          *@processed_params.collect do |key, value|
+            [key, value] if @props[key] == new_props[key]
+          end.compact.flatten(1)
+        ]
+      end
+
+      def initialize(props, current_props_wrapper=nil)
         @props = props || {}
-        @processed_params = {}
+        @processed_params = if current_props_wrapper
+          current_props_wrapper.unchanged_processed_params(props)
+        else
+          {}
+        end
       end
 
       def [](prop)

spec/react/param_declaration_spec.rb

@@ -195,25 +195,55 @@ def render
       expect(`window.dummy_log`).to eq(["Warning: Failed propType: In component `Foo`\nProvided prop `foo` could not be converted to BazWoggle"])
     end
 
-    it "can will only convert once" do
-      stub_const "BazWoggle", Class.new
-      BazWoggle.class_eval do
-        def initialize(kind)
-          @kind = kind
+    describe "converts params only once" do
+
+      it "not on every access" do
+        stub_const "BazWoggle", Class.new
+        BazWoggle.class_eval do
+          def initialize(kind)
+            @kind = kind
+          end
+          attr_accessor :kind
+          def self._react_param_conversion(json, validate_only)
+            new(json[:bazwoggle]) if json[:bazwoggle]
+          end
         end
-        attr_accessor :kind
-        def self._react_param_conversion(json, validate_only)
-          new(json[:bazwoggle]) if json[:bazwoggle]
+        Foo.class_eval do
+          param :foo, type: BazWoggle
+          def render
+            params.foo.kind = params.foo.kind+1
+            "#{params.foo.kind}"
+          end
         end
+        expect(React.render_to_static_markup(React.create_element(Foo, foo: {bazwoggle: 1}))).to eq('<span>2</span>')
       end
-      Foo.class_eval do
-        param :foo, type: BazWoggle
-        def render
-          params.foo.kind = params.foo.kind+1
-          "#{params.foo.kind}"
+
+      it "not after state update" do
+        stub_const "BazWoggle", Class.new
+        BazWoggle.class_eval do
+          def initialize(kind)
+            @kind = kind
+          end
+          attr_accessor :kind
+          def self._react_param_conversion(json, validate_only)
+            new(json[:bazwoggle]) if json[:bazwoggle]
+          end
+        end 
+        Foo.class_eval do
+          param :foo, type: BazWoggle
+          export_state :change_me
+          before_mount do
+            params.foo.kind = params.foo.kind+1
+          end
+          def render
+            "#{params.foo.kind} - #{Foo.change_me}"
+          end
         end
+        div = `document.createElement("div")`
+        React.render(React.create_element(Foo, foo: {bazwoggle: 1}), div)
+        Foo.change_me! "updated"
+        expect(`div.children[0].innerHTML`).to eq("2 - updated")
       end
-      expect(React.render_to_static_markup(React.create_element(Foo, foo: {bazwoggle: 1}))).to eq('<span>2</span>')
     end
 
     it "will alias a Proc type param" do