hyper-react 0.11.0 → 0.12.0

data/lib/react/component/base.rb

@@ -2,7 +2,11 @@ module React
   module Component
     class Base
       def self.inherited(child)
-        child.include(Component)
+        # note this is turned off during old style testing:  See the spec_helper
+        unless child.to_s == "React::Component::HyperTestDummy"
+          React::Component.deprecation_warning child, "The class name React::Component::Base has been deprecated.  Use Hyperloop::Component instead."
+        end
+        child.include(ComponentNoNotice)
       end
     end
   end

data/lib/react/component/class_methods.rb

@@ -3,6 +3,10 @@ module React
     # class level methods (macros) for components
     module ClassMethods
 
+      def deprecation_warning(message)
+        React::Component.deprecation_warning(self, message)
+      end
+
       def reactrb_component?
         true
       end
@@ -113,51 +117,22 @@ module React
       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
         states_hash = (states.last.is_a?(Hash)) ? states.pop : {}
-        states.each { |name| states_hash[name] = default_initial_value }
-        (self.initial_state ||= {}).merge! states_hash
-        states_hash.each do |name, initial_value|
-          define_state_methods(self, name, &block)
-        end
+        states.each { |name| state(name => default_initial_value) } # was states_hash[name] = default_initial_value
+        states_hash.each { |name, value| state(name => value) }
       end
 
       def export_state(*states, &block)
+        deprecation_warning "'export_state' is deprecated. Use the 'state' macro to declare states."
         default_initial_value = (block && block.arity == 0) ? yield : nil
         states_hash = (states.last.is_a?(Hash)) ? states.pop : {}
         states.each { |name| states_hash[name] = default_initial_value }
-        State.initialize_states(self, states_hash)
-        states_hash.each do |name, initial_value|
-          define_state_methods(self, name, self, &block)
-          define_state_methods(singleton_class, name, self, &block)
-        end
-      end
-
-      def define_state_methods(this, name, from = nil, &block)
-        this.define_method("#{name}") do
-          React::Component.deprecation_warning "Direct access to state `#{name}`.  Use `state.#{name}` instead." if from.nil? || from == this
-          State.get_state(from || self, name)
-        end
-        this.define_method("#{name}=") do |new_state|
-          React::Component.deprecation_warning "Direct assignment to state `#{name}`.  Use `#{(from && from != this) ? from : 'state'}.#{name}!` instead."
-          yield name, State.get_state(from || self, name), new_state if block && block.arity > 0
-          State.set_state(from || self, name, new_state)
-        end
-        this.define_method("#{name}!") do |*args|
-          React::Component.deprecation_warning "Direct access to state `#{name}`.  Use `state.#{name}` instead."  if from.nil? or from == this
-          if args.count > 0
-            yield name, State.get_state(from || self, name), args[0] if block && block.arity > 0
-            current_value = State.get_state(from || self, name)
-            State.set_state(from || self, name, args[0])
-            current_value
-          else
-            current_state = State.get_state(from || self, name)
-            yield name, State.get_state(from || self, name), current_state if block && block.arity > 0
-            State.set_state(from || self, name, current_state)
-            Observable.new(current_state) do |update|
-              yield name, State.get_state(from || self, name), update if block && block.arity > 0
-              State.set_state(from || self, name, update)
-            end
+        states_hash.each do |name, value|
+          state(name => value, scope: :class, reader: true)
+          singleton_class.define_method("#{name}!") do |*args|
+            mutate.__send__(name, *args)
           end
         end
       end

data/lib/react/component/dsl_instance_methods.rb

@@ -18,10 +18,6 @@ module React
       def refs
         Hash.new(`#{@native}.refs`)
       end
-
-      def state
-        @state_wrapper ||= StateWrapper.new(@native, self)
-      end
     end
   end
 end

data/lib/react/component/props_wrapper.rb

@@ -1,11 +1,6 @@
 module React
   module Component
 
-    def deprecated_params_method(name, *args, &block)
-      React::Component.deprecation_warning"Direct access to param `#{name}`.  Use `params.#{name}` instead."
-      params.send(name, *args, &block)
-    end
-
     class PropsWrapper
       attr_reader :component
 

data/lib/react/component/should_component_update.rb

@@ -83,13 +83,9 @@ module React
       end
       # rubocop:enable Metrics/MethodLength
 
-      # Do a shallow compare on the two hashes. Starting in 0.9 we will do a deep compare.
+      # Do a shallow compare on the two hashes. Starting in 0.9 we will do a deep compare. ???
 
       def props_changed?(next_params)
-        Component.deprecation_warning(
-          "Using shallow incoming params comparison.\n"\
-          'Do a require "reactrb/deep-compare, to get 0.9 behavior'
-        )
         (props.keys.sort != next_params.keys.sort) ||
           next_params.detect { |k, v| `#{v} != #{@native}.props[#{k}]` }
       end

data/lib/react/component/tags.rb

@@ -27,18 +27,12 @@ module React
                   %w(circle clipPath defs ellipse g line linearGradient mask path pattern polygon polyline
                   radialGradient rect stop svg text tspan)
 
-      # note: any tag can end in _as_node but this is deprecated
-
       # the present method is retained as a legacy behavior
 
       def present(component, *params, &children)
         React::RenderingContext.render(component, *params, &children)
       end
 
-      def present_as_node(component, *params, &children)
-        React::RenderingContext.build_only(component, *params, &children)
-      end
-
       # define each predefined tag as an instance method
 
 
@@ -64,10 +58,6 @@ module React
           #const_set tag.upcase, React.create_element(tag)
           #Object.const_set tag.upcase, Class.new(HtmlTagWrapper)
         end
-        # handle deprecated _as_node style
-        define_method("#{tag}_as_node") do |*params, &children|
-          React::RenderingContext.build_only(tag, *params, &children)
-        end
       end
 
       def self.html_tag_class_for(tag)
@@ -81,14 +71,8 @@ module React
       # where there is no preceeding scope.
 
       def method_missing(name, *params, &children)
-        if name =~ /_as_node$/
-          # handle deprecated _as_node style
-          component = find_component(name.gsub(/_as_node$/, ''))
-          return React::RenderingContext.build_only(component, *params, &children) if component
-        else
-          component = find_component(name)
-          return React::RenderingContext.render(component, *params, &children) if component
-        end
+        component = find_component(name)
+        return React::RenderingContext.render(component, *params, &children) if component
         Object.method_missing(name, *params, &children)
       end
 
@@ -97,16 +81,17 @@ module React
 
       class << self
         def included(component)
-          _name, parent = find_name_and_parent(component)
-          class << parent
-            define_method _name do |*params, &children|
+          name, parent = find_name_and_parent(component)
+          tag_names_module = Module.new do
+            define_method name do |*params, &children|
               React::RenderingContext.render(component, *params, &children)
             end
             # handle deprecated _as_node style
-            define_method "#{_name}_as_node" do |*params, &children|
+            define_method "#{name}_as_node" do |*params, &children|
               React::RenderingContext.build_only(component, *params, &children)
             end
           end
+          parent.extend(tag_names_module)
         end
 
         private

data/lib/react/config.rb

@@ -0,0 +1,5 @@
+if RUBY_ENGINE != 'opal'
+  require "react/config/server"
+else
+  require "react/config/client"
+end

data/lib/react/config/client.rb.erb

@@ -0,0 +1,19 @@
+if RUBY_ENGINE == 'opal'
+  module React
+    module Config
+      extend self
+      def environment=(value)
+        raise "Environment cannot be configured at runtime."
+      end
+
+      def config
+        hash = %x{
+          Opal.hash({
+            environment: <%= '"' + React::Config.config[:environment] + '"' %>
+          })
+        }
+        hash
+      end
+    end
+  end
+end

data/lib/react/config/server.rb

@@ -0,0 +1,20 @@
+if RUBY_ENGINE != 'opal'
+  module React
+    module Config
+      extend self
+      def environment=(value)
+        config[:environment] = value
+      end
+
+      def config
+        @config ||= default_config
+      end
+
+      def default_config
+        {
+          environment: ENV['RACK_ENV'] || 'development'
+        }
+      end
+    end
+  end
+end

data/lib/react/element.rb

@@ -156,6 +156,7 @@ module React
       prop_name = "_on#{event_name.event_camelize}"
       fn = %x{function(){#{
         React::Component.deprecation_warning(
+          type,
           "In future releases React::Element#on('#{event_name}') will no longer respond "\
           "to the '#{prop_name}' emitter.\n"\
           "Rename your emitter param to 'on_#{event_name}' or use .on('<#{prop_name}>')"

data/lib/react/native_library.rb

@@ -45,17 +45,12 @@ module React
         import_const_from_native(self, const_name, true) || super
       end
 
-      def method_missing(method_name, *args, &block)
-        method = method_name.gsub(/_as_node$/, '') # remove once _as_node is deprecated.
+      def method_missing(method, *args, &block)
         component_class = get_const(method) if const_defined?(method)
         component_class ||= import_const_from_native(self, method, false)
         raise 'could not import a react component named: '\
               "#{scope_native_name method}" unless component_class
-        if method == method_name
-          React::RenderingContext.render(component_class, *args, &block)
-        else # remove once _as_node is deprecated.
-          React::RenderingContext.build_only(component_class, *args, &block)
-        end
+        React::RenderingContext.render(component_class, *args, &block)
       end
 
       private

data/lib/react/react-source-browser.rb

@@ -0,0 +1,3 @@
+if RUBY_ENGINE == 'opal'
+  require 'react.js'
+end

data/lib/react/react-source-server.rb

@@ -0,0 +1,3 @@
+if RUBY_ENGINE == 'opal'
+  require "react-server.js"
+end

data/lib/react/react-source.rb

@@ -1,9 +1,20 @@
 if RUBY_ENGINE == 'opal'
+  %x{
+    var ms = [
+      "Warning: `react/react-source` is deprecated, ",
+      "use `react/react-source-browser` or `react/react-source-server` instead."
+    ]
+    console.error(ms.join(""));
+  }
   require 'react.js'
   require "react-server.js"
 else
+  require "react/config"
   require "react/rails/asset_variant"
-  react_directory = React::Rails::AssetVariant.new(addons: true).react_directory
+  react_directory = React::Rails::AssetVariant.new(
+    addons: true,
+    variant: React::Config.config[:environment].to_sym
+  ).react_directory
   Opal.append_path react_directory.untaint
   Opal.append_path File.expand_path('../../react-sources/', __FILE__).untaint
 end

data/lib/react/ref_callback.rb

@@ -0,0 +1,31 @@
+require 'react/native_library'
+
+module React
+  module RefsCallbackExtension
+  end
+
+  class API
+    class << self
+      alias :orig_convert_props :convert_props
+    end
+
+    def self.convert_props(properties)
+      props = self.orig_convert_props(properties)
+      props.map do |key, value|
+        if key == "ref" && value.is_a?(Proc)
+          new_proc = Proc.new do |native_inst|
+            if `#{native_inst}._getOpalInstance !== undefined`
+              value.call(`#{native_inst}._getOpalInstance()`)
+            elsif `React.findDOMNode !== undefined && #{native_inst}.nodeType === undefined`
+              value.call(`React.findDOMNode(#{native_inst})`)
+            else
+              value.call(native_inst)
+            end
+          end
+          props[key] = new_proc
+        end
+      end
+      props
+    end
+  end
+end

data/lib/react/rendering_context.rb

@@ -3,14 +3,9 @@ module React
     class << self
       attr_accessor :waiting_on_resources
 
-      def build_only(name, *args, &block)
-        React::Component.deprecation_warning(
-          '..._as_node is deprecated.  Render component and then use the .node method instead'
-        )
-        React::RenderingContext.build { React::RenderingContext.render(name, *args, &block) }.to_n
-      end
-
       def render(name, *args, &block)
+        was_outer_most = !@not_outer_most
+        @not_outer_most = true
         remove_nodes_from_args(args)
         @buffer ||= [] unless @buffer
         if block
@@ -38,6 +33,8 @@ module React
         @buffer << element
         self.waiting_on_resources = nil
         element
+      ensure
+        @not_outer_most = @buffer = nil if was_outer_most
       end
 
       def build
@@ -65,7 +62,10 @@ module React
 
       def remove_nodes_from_args(args)
         args[0].each do |key, value|
-          value.as_node if value.is_a?(Element) rescue nil
+          begin
+            value.as_node if value.is_a?(Element)
+          rescue Exception
+          end
         end if args[0] && args[0].is_a?(Hash)
       end
 
@@ -92,7 +92,7 @@ module React
       def run_child_block(is_outer_scope)
         result = yield
         result = result.to_s if result.try :acts_as_string?
-        @buffer << result if result.is_a?(String) || (result.is_a?(Element) && @buffer.empty?)
+        @buffer << result if result.is_a?(String) || (result.is_a?(React::Element) && @buffer.empty?)
         raise_render_error(result) if is_outer_scope && @buffer != [result]
       end
 

data/lib/react/server.rb

@@ -0,0 +1,23 @@
+module React
+  module Server
+    def self.render_to_string(element)
+      if !(`typeof ReactDOMServer === 'undefined'`)
+        React::RenderingContext.build { `ReactDOMServer.renderToString(#{element.to_n})` } # v0.15+
+      elsif !(`typeof React.renderToString === 'undefined'`)
+        React::RenderingContext.build { `React.renderToString(#{element.to_n})` }
+      else
+        raise "renderToString is not defined.  In React >= v15 you must import it with ReactDOMServer"
+      end
+    end
+
+    def self.render_to_static_markup(element)
+      if !(`typeof ReactDOMServer === 'undefined'`)
+        React::RenderingContext.build { `ReactDOMServer.renderToStaticMarkup(#{element.to_n})` } # v0.15+
+      elsif !(`typeof React.renderToString === 'undefined'`)
+        React::RenderingContext.build { `React.renderToStaticMarkup(#{element.to_n})` }
+      else
+        raise "renderToStaticMarkup is not defined.  In React >= v15 you must import it with ReactDOMServer"
+      end
+    end
+  end
+end

data/lib/react/state_wrapper.rb

@@ -0,0 +1,23 @@
+module HyperStore
+  class StateWrapper < BaseStoreClass # < BasicObject
+
+    def [](state)
+      `#{__from__.instance_variable_get('@native')}.state[#{state}] || #{nil}`
+    end
+
+    def []=(state, new_value)
+      `#{__from__.instance_variable_get('@native')}.state[#{state}] = new_value`
+    end
+
+    alias pre_component_method_missing method_missing
+
+    def method_missing(method, *args)
+      if method =~ /\!$/ && __from__.respond_to?(:deprecation_warning)
+        __from__.deprecation_warning("The mutator 'state.#{method}' has been deprecated.  Use 'mutate.#{method.gsub(/\!$/,'')}' instead.")
+        __from__.mutate.__send__(method.gsub(/\!$/,''), *args)
+      else
+        pre_component_method_missing(method, *args)
+      end
+    end
+  end
+end

data/lib/react/test/matchers/render_html_matcher.rb

@@ -22,15 +22,17 @@ module React
           failure_string
         end
 
-        def negative_failure_message
+        def failure_message_when_negated
           failure_string(:negative)
         end
 
+        alias negative_failure_message failure_message_when_negated
+
         private
 
         def render_to_html
           element = React.create_element(@component, @params)
-          React.render_to_static_markup(element)
+          React::Server.render_to_static_markup(element)
         end
 
         def failure_string(negative = false)