reactive-ruby 0.7.31 → 0.7.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 03ea6c95ebe59edebe184cba6f058d429f6e9f03
-  data.tar.gz: f68ee94ee71d55e877a19f253f012da2cba98fa1
+  metadata.gz: 212dc6ace47eb491a9464258c6df6e26e4c35579
+  data.tar.gz: faa7ee755e54749e9acce87bc8c08ff1c890bc88
 SHA512:
-  metadata.gz: 51dffbcc520e2969b83f04c4820af42c100f7d3b6f340a5468e0dc847330a4f5fe4fdfa54722a0bb7a266de19bc827e6d3ed23cc66b27f1a2f6910ce32be66dd
-  data.tar.gz: 29ee24cee796f6ada843fbac91dd089a5d421d44be2318ba1dd5b1d600fa8c3b4e48ef4f8bd5a4d21cf3ee616c584cc77d87659f17a741083f7bc66705e14a50
+  metadata.gz: 4b721773a255f59e5a852788fd75a4fd2ab7340b9c8f8e5d0846ca009adf0d37150fb83010ad80810e203352467744f81cc10008c3daeff0b97898f1cacf8971
+  data.tar.gz: 4b53af87056f9a2dbe19eddcd1217b7ab95daa705edb90011501702e956a97200dd28fff5e4396b30735c0344e408ee3b0cf8b7693294f6c01159307afbe5b15

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    reactive-ruby (0.7.30)
+    reactive-ruby (0.7.31)
       opal
       opal-activesupport (>= 0.2.0)
       opal-browser

data/lib/rails-helpers/top_level_rails_component.rb

@@ -8,33 +8,33 @@ module React
 
     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

data/lib/react/callbacks.rb

@@ -7,9 +7,7 @@ module React
     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 @@ module React
           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

data/lib/react/component.rb

@@ -14,6 +14,22 @@ module React
     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 +39,11 @@ module React
         define_callback :after_update
         define_callback :before_unmount
 
+        def deprecated_params_method(name, *args, &block)
+          self.class.deprecation_warning "Direct access to param `#{name}`.  Use `params.#{name}` instead."
+          params.send(name, *args, &block)
+        end
+
         def render
           raise "no render defined"
         end unless method_defined?(:render)
@@ -97,6 +118,11 @@ module React
     end
 
     def params
+      @props_wrapper
+      #Hash.new(`#{@native}.props`)
+    end
+
+    def props
       Hash.new(`#{@native}.props`)
     end
 
@@ -105,8 +131,8 @@ module React
     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 @@ module React
 
     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 @@ module React
       # 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 @@ module React
 
     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 @@ module React
     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

data/lib/react/component/base.rb

@@ -0,0 +1,11 @@
+require 'react/component'
+
+module React
+  module Component
+    class Base
+      def self.inherited(child)
+        child.send(:include, React::Component)
+      end
+    end
+  end
+end

data/lib/react/component/class_methods.rb

@@ -18,8 +18,17 @@ module React
         raise e if reraise
       end
 
+      def deprecation_warning(message)
+        @deprecation_messages ||= []
+        message = "Warning: Deprecated feature used in #{self.name}. #{message}"
+        unless @deprecation_messages.include? message
+          @deprecation_messages << message
+          IsomorphicHelpers.log message, :warning
+        end
+      end
+
       def validator
-        @validator ||= React::Validator.new
+        @validator ||= React::Validator.new(self)
       end
 
       def prop_types
@@ -47,50 +56,73 @@ module React
       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 = {})
+        deprecation_warning "`required_param` is deprecated, use `param` instead."
         validator.requires(name, options)
-        define_param_method(name, options[:type])
       end
 
       alias_method :require_param, :required_param
 
       def optional_param(name, options = {})
+        deprecation_warning "`optional_param` is deprecated, use `param param_name: default_value` instead."
         validator.optional(name, options)
-        define_param_method(name, options[:type]) unless name == :params
       end
 
       def collect_other_params_as(name)
@@ -123,14 +155,16 @@ module React
 
       def define_state_methods(this, name, from = nil, &block)
         this.define_method("#{name}") do
+          self.class.deprecation_warning "Direct access to state `#{name}`.  Use `state.#{name}` instead." if from.nil? || from == this
           React::State.get_state(from || self, name)
         end
         this.define_method("#{name}=") do |new_state|
+          self.class.deprecation_warning "Direct assignment to state `#{name}`.  Use `#{(from && from != this) ? from : 'state'}.#{name}!` instead."
           yield name, React::State.get_state(from || self, name), new_state if block && block.arity > 0
           React::State.set_state(from || self, name, new_state)
         end
         this.define_method("#{name}!") do |*args|
-          #return unless @native
+          self.class.deprecation_warning "Direct access to state `#{name}`.  Use `state.#{name}` instead."  if from.nil? or from == this
           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)

data/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 @@ module React
           @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

data/lib/react/top_level.rb

@@ -1,6 +1,6 @@
 require "native"
 require 'active_support'
-require 'react/component'
+require 'react/component/base'
 
 module React
   HTML_TAGS = %w(a abbr address area article aside audio b base bdi bdo big blockquote body br
@@ -49,4 +49,13 @@ module React
   def self.unmount_component_at_node(node)
     `React.unmountComponentAtNode(node.$$class ? node[0] : node)`
   end
+
 end
+
+Element.instance_eval do
+  class ::Element::DummyContext < React::Component::Base
+  end
+  def render(&block)
+    React.render(React::RenderingContext.render(nil) {::Element::DummyContext.new.instance_eval &block}, self)
+  end
+end if Object.const_defined?("Element")

data/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 @@ module React
     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 @@ module React
 
     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
 

data/lib/reactive-ruby.rb

@@ -2,6 +2,7 @@ if RUBY_ENGINE == 'opal'
   require 'sources/react.js'
   require 'react/top_level'
   require 'react/component'
+  require 'react/component/base'
   require 'react/element'
   require 'react/event'
   require 'react/api'

data/lib/reactive-ruby/component_loader.rb

@@ -4,6 +4,9 @@ module ReactiveRuby
     private :v8_context
 
     def initialize(v8_context)
+      unless v8_context
+        raise ArgumentError.new('Could not obtain ExecJS runtime context')
+      end
       @v8_context = v8_context
     end
 

data/lib/reactive-ruby/version.rb

@@ -1,3 +1,3 @@
 module React
-  VERSION = "0.7.31"
+  VERSION = "0.7.32"
 end

data/spec/react/component_base_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+if opal?
+describe React::Component::Base do
+  after(:each) do
+    React::API.clear_component_class_cache
+  end
+
+  it 'can be inherited to create a component class' do
+    stub_const 'Foo', Class.new(React::Component::Base)
+    Foo.class_eval do
+      before_mount do
+        @instance_data = ["working"]
+      end
+      def render
+        @instance_data.first
+      end
+    end
+    stub_const 'Bar', Class.new(Foo)
+    Bar.class_eval do
+      before_mount do
+        @instance_data << "well"
+      end
+      def render
+        @instance_data.join(" ")
+      end
+    end
+    expect(React.render_to_static_markup(React.create_element(Foo))).to eq("<span>working</span>")
+    expect(React.render_to_static_markup(React.create_element(Bar))).to eq("<span>working well</span>")
+  end
+
+end
+end

data/spec/react/component_spec.rb

@@ -102,6 +102,58 @@ describe React::Component do
     end
   end
 
+  describe 'New style setter & getter' do
+    before(:each) do
+      stub_const 'Foo', Class.new
+      Foo.class_eval do
+        include React::Component
+        def render
+          div { state.foo }
+        end
+      end
+    end
+
+    it 'implicitly will create a state variable when first written' do
+      Foo.class_eval do
+        before_mount do
+          state.foo! 'bar'
+        end
+      end
+
+      expect(React.render_to_static_markup(React.create_element(Foo))).to eq('<div>bar</div>')
+    end
+
+    it 'returns an observer with the bang method and no arguments' do
+      Foo.class_eval do
+        before_mount do
+          state.foo!(state.baz!.class.name)
+        end
+      end
+
+      expect(React.render_to_static_markup(React.create_element(Foo))).to eq('<div>React::Observable</div>')
+    end
+
+    it 'returns the current value of a state when written' do
+      Foo.class_eval do
+        before_mount do
+          state.baz! 'bar'
+          state.foo!(state.baz!('pow'))
+        end
+      end
+
+      expect(React.render_to_static_markup(React.create_element(Foo))).to eq('<div>bar</div>')
+    end
+
+    it 'can access an explicitly defined state`' do
+      Foo.class_eval do
+        define_state foo: :bar
+      end
+
+      expect(React.render_to_static_markup(React.create_element(Foo))).to eq('<div>bar</div>')
+    end
+
+  end
+
   describe 'State setter & getter' do
     before(:each) do
       stub_const 'Foo', Class.new
@@ -359,11 +411,11 @@ describe React::Component do
 
         %x{
           var log = [];
-          var org_console = window.console;
-          window.console = {warn: function(str){log.push(str)}}
+          var org_warn_console = window.console.warn;
+          window.console.warn = function(str){log.push(str)}
         }
         renderToDocument(Foo, bar: 10, lorem: Lorem.new)
-        `window.console = org_console;`
+        `window.console.warn = org_warn_console;`
         expect(`log`).to eq(["Warning: Failed propType: In component `Foo`\nRequired prop `foo` was not specified\nProvided prop `bar` could not be converted to String"])
       end
 
@@ -381,11 +433,11 @@ describe React::Component do
 
         %x{
           var log = [];
-          var org_console = window.console;
-          window.console = {warn: function(str){log.push(str)}}
+          var org_warn_console = window.console.warn;
+          window.console.warn = function(str){log.push(str)}
         }
         renderToDocument(Foo, foo: 10, bar: '10', lorem: Lorem.new)
-        `window.console = org_console;`
+        `window.console.warn = org_warn_console;`
         expect(`log`).to eq([])
       end
     end

data/spec/react/observable_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+if opal?
+describe 'React::Observable' do
+  # tbd
+end
+end

data/spec/react/param_declaration_spec.rb

@@ -1,18 +1,187 @@
 require 'spec_helper'
 
 if opal?
-describe 'the required_param macro' do
-  it "can be used to declare a required param"                              # required_param :foo
-  it "can have a simple type"                                               # required_param :foo, type: String
-  it "can use the [] notation for arrays"                                   # required_param :foo, type: []
-  it "can use the [] notation for arrays of a specific type"                # required_param :foo, type: [String]
-  it "can convert a json hash to a type"                                    # required_param :foo, type: BazWoggle # requires a BazWoggle conversion be provided
-  it "will alias a Proc type param"                                         # required_param :foo, type: Proc # we can just say foo(...) to call the proc
-  it "will bind a two way linkage to an observable param"                   # required_param :foo, type: React::Observable # defines foo, and foo! bound to the observer
-    # you can create an observable simply by passing the value of some state!
-end
-describe 'the optional_param macro' do
-  # works just like a required_param, and
-  it "can have a default value"                                             # optional_param :foo, type: String, default: ""
+
+describe 'the param macro' do
+
+  it "can create and access a required param" do
+    stub_const 'Foo', Class.new(React::Component::Base)
+    Foo.class_eval do
+      param :foo
+
+      def render
+        div { params.foo }
+      end
+    end
+
+    expect(React.render_to_static_markup(React.create_element(Foo, {foo: :bar}))).to eq('<div>bar</div>')
+  end
+
+  it "can create and access an optional params" do
+    stub_const 'Foo', Class.new(React::Component::Base)
+    Foo.class_eval do
+
+      param foo1: :no_bar1
+      param foo2: :no_bar2
+      param :foo3, default: :no_bar3
+      param :foo4, default: :no_bar4
+
+      def render
+        div { "#{params.foo1}-#{params.foo2}-#{params.foo3}-#{params.foo4}" }
+      end
+    end
+
+    expect(React.render_to_static_markup(React.create_element(Foo, {foo1: :bar1, foo3: :bar3}))).to eq('<div>bar1-no_bar2-bar3-no_bar4</div>')
+  end
+
+  it 'can specify validation rules with the type option' do
+    stub_const 'Foo', Class.new(React::Component::Base)
+    Foo.class_eval do
+      param :foo, type: String
+    end
+
+    expect(Foo.prop_types).to have_key(:_componentValidator)
+  end
+
+  it "can type check params" do
+    stub_const 'Foo', Class.new(React::Component::Base)
+    Foo.class_eval do
+
+      param :foo1, type: String
+      param :foo2, type: String
+
+      def render
+        div { "#{params.foo1}-#{params.foo2}" }
+      end
+    end
+
+    expect(React.render_to_static_markup(React.create_element(Foo, {foo1: 12, foo2: "string"}))).to eq('<div>12-string</div>')
+  end
+
+  it 'logs error in warning if validation failed' do
+    stub_const 'Lorem', Class.new
+    stub_const 'Foo2', Class.new(React::Component::Base)
+    Foo2.class_eval do
+      param :foo
+      param :lorem, type: Lorem
+      param :bar, default: nil, type: String
+      def render; div; end
+    end
+
+    %x{
+      var log = [];
+      var org_warn_console = window.console.warn;
+      window.console.warn = function(str){log.push(str)}
+    }
+    renderToDocument(Foo2, bar: 10, lorem: Lorem.new)
+    `window.console.warn = org_warn_console;`
+    expect(`log`).to eq(["Warning: Failed propType: In component `Foo2`\nRequired prop `foo` was not specified\nProvided prop `bar` could not be converted to String"])
+  end
+
+  it 'should not log anything if validation passes' do
+    stub_const 'Lorem', Class.new
+    stub_const 'Foo', Class.new(React::Component::Base)
+    Foo.class_eval do
+      param :foo
+      param :lorem, type: Lorem
+      param :bar, default: nil, type: String
+
+      def render; div; end
+    end
+
+    %x{
+      var log = [];
+      var org_warn_console = window.console.warn;
+      window.console.warn = function(str){log.push(str)}
+    }
+    renderToDocument(Foo, foo: 10, bar: '10', lorem: Lorem.new)
+    `window.console.warn = org_warn_console;`
+    expect(`log`).to eq([])
+  end
+
+  describe 'advanced type handling' do
+    before(:each) do
+      %x{
+        window.dummy_log = [];
+        window.org_warn_console = window.console.warn;
+        window.console.warn = function(str){window.dummy_log.push(str)}
+      }
+      stub_const 'Foo', Class.new(React::Component::Base)
+      Foo.class_eval { def render; ""; end }
+    end
+    after(:each) do
+      `window.console.warn = window.org_warn_console;`
+    end
+
+    it "can use the [] notation for arrays" do
+      Foo.class_eval do
+        param :foo, type: []
+        param :bar, type: []
+      end
+      renderToDocument(Foo, foo: 10, bar: [10])
+      expect(`window.dummy_log`).to eq(["Warning: Failed propType: In component `Foo`\nProvided prop `foo` could not be converted to Array"])
+    end
+
+    it "can use the [xxx] notation for arrays of a specific type" do
+      Foo.class_eval do
+        param :foo, type: [String]
+        param :bar, type: [String]
+      end
+      renderToDocument(Foo, foo: [10], bar: ["10"])
+      expect(`window.dummy_log`).to eq(["Warning: Failed propType: In component `Foo`\nProvided prop `foo`[0] could not be converted to String"])
+    end
+
+    it "can convert a json hash to a type" 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
+        param :bar, type: BazWoggle
+        param :baz, type: [BazWoggle]
+        def render
+          "#{params.bar.kind}, #{params.baz[0].kind}"
+        end
+      end
+      expect(React.render_to_static_markup(React.create_element(
+        Foo, foo: "", bar: {bazwoggle: 1}, baz: [{bazwoggle: 2}]))).to eq('<span>1, 2</span>')
+      expect(`window.dummy_log`).to eq(["Warning: Failed propType: In component `Foo`\nProvided prop `foo` could not be converted to BazWoggle"])
+    end
+
+    it "will alias a Proc type param" do
+      Foo.class_eval do
+        param :foo, type: Proc
+        def render
+          params.foo
+        end
+      end
+      expect(React.render_to_static_markup(React.create_element(Foo, foo: lambda { 'works!' }))).to eq('<span>works!</span>')
+    end
+
+    it "will create a 'bang' (i.e. update) method if the type is React::Observable" do
+      Foo.class_eval do
+        param :foo, type: React::Observable
+        before_mount do
+          params.foo! "ha!"
+        end
+        def render
+          params.foo
+        end
+      end
+      current_state = ""
+      observer = React::Observable.new(current_state) { |new_state| current_state = new_state }
+      expect(React.render_to_static_markup(React.create_element(Foo, foo: observer))).to eq('<span>ha!</span>')
+      expect(current_state).to eq("ha!")
+    end
+
+  end
+
 end
 end

data/spec/react/validator_spec.rb

@@ -2,10 +2,13 @@ require "spec_helper"
 
 if opal?
 describe React::Validator do
+  before do
+    stub_const 'Foo', Class.new(React::Component::Base)
+  end
   describe '#validate' do
     describe "Presence validation" do
       it "should check if required props provided" do
-        validator = React::Validator.build do
+        validator = React::Validator.new(Foo).build do
           requires :foo
           requires :bar
         end
@@ -15,7 +18,7 @@ describe React::Validator do
       end
 
       it "should check if passed non specified prop" do
-        validator = React::Validator.build do
+        validator = React::Validator.new(Foo).build do
           optional :foo
         end
 
@@ -26,7 +29,7 @@ describe React::Validator do
 
     describe "Type validation" do
       it "should check if passed value with wrong type" do
-        validator = React::Validator.build do
+        validator = React::Validator.new(Foo).build do
           requires :foo, type: String
         end
 
@@ -36,7 +39,7 @@ describe React::Validator do
 
       it "should check if passed value with wrong custom type" do
         stub_const 'Bar', Class.new
-        validator = React::Validator.build do
+        validator = React::Validator.new(Foo).build do
           requires :foo, type: Bar
         end
 
@@ -45,7 +48,7 @@ describe React::Validator do
       end
 
       it 'coerces native JS prop types to opal objects' do
-        validator = React::Validator.build do
+        validator = React::Validator.new(Foo).build do
           requires :foo, type: `{ x: 1 }`
         end
 
@@ -54,7 +57,7 @@ describe React::Validator do
       end
 
       it 'coerces native JS values to opal objects' do
-        validator = React::Validator.build do
+        validator = React::Validator.new(Foo).build do
           requires :foo, type: Array[Fixnum]
         end
 
@@ -63,7 +66,7 @@ describe React::Validator do
       end
 
       it "should support Array[Class] validation" do
-        validator = React::Validator.build do
+        validator = React::Validator.new(Foo).build do
           requires :foo, type: Array[Hash]
         end
 
@@ -80,7 +83,7 @@ describe React::Validator do
 
     describe "Limited values" do
       it "should check if passed value is not one of the specified values" do
-        validator = React::Validator.build do
+        validator = React::Validator.new(Foo).build do
           requires :foo, values: [4,5,6]
         end
 
@@ -93,7 +96,7 @@ describe React::Validator do
   describe '#undefined_props' do
     let(:props) { { foo: 'foo', bar: 'bar', biz: 'biz', baz: 'baz' } }
     let(:validator) do
-      React::Validator.build do
+      React::Validator.new(Foo).build do
         requires :foo
         optional :bar
       end
@@ -112,7 +115,7 @@ describe React::Validator do
 
   describe "default_props" do
     it "should return specified default values" do
-      validator = React::Validator.build do
+      validator = React::Validator.new(Foo).build do
         requires :foo, default: 10
         requires :bar
         optional :lorem, default: 20

data/spec/reactive-ruby/component_loader_spec.rb

@@ -12,6 +12,14 @@ RSpec.describe ReactiveRuby::ComponentLoader do
   let(:context) { ExecJS.compile(GLOBAL_WRAPPER + js) }
   let(:v8_context) { context.instance_variable_get(:@v8_context) }
 
+  describe '.new' do
+    it 'raises a meaningful exception when initialized without a context' do
+      expect {
+        described_class.new(nil)
+      }.to raise_error(/Could not obtain ExecJS runtime context/)
+    end
+  end
+
   describe '#load' do
     it 'loads given asset file into context' do
       loader = described_class.new(v8_context)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reactive-ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.31
+  version: 0.7.32
 platform: ruby
 authors:
 - David Chang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-23 00:00:00.000000000 Z
+date: 2015-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal
@@ -262,6 +262,7 @@ files:
 - lib/react/callbacks.rb
 - lib/react/component.rb
 - lib/react/component/api.rb
+- lib/react/component/base.rb
 - lib/react/component/class_methods.rb
 - lib/react/element.rb
 - lib/react/event.rb
@@ -292,11 +293,13 @@ files:
 - spec/controller_helper_spec.rb
 - spec/index.html.erb
 - spec/react/callbacks_spec.rb
+- spec/react/component_base_spec.rb
 - spec/react/component_spec.rb
 - spec/react/dsl_spec.rb
 - spec/react/element_spec.rb
 - spec/react/event_spec.rb
 - spec/react/native_library_spec.rb
+- spec/react/observable_spec.rb
 - spec/react/param_declaration_spec.rb
 - spec/react/react_spec.rb
 - spec/react/react_state_spec.rb
@@ -338,11 +341,13 @@ test_files:
 - spec/controller_helper_spec.rb
 - spec/index.html.erb
 - spec/react/callbacks_spec.rb
+- spec/react/component_base_spec.rb
 - spec/react/component_spec.rb
 - spec/react/dsl_spec.rb
 - spec/react/element_spec.rb
 - spec/react/event_spec.rb
 - spec/react/native_library_spec.rb
+- spec/react/observable_spec.rb
 - spec/react/param_declaration_spec.rb
 - spec/react/react_spec.rb
 - spec/react/react_state_spec.rb