isomorfeus-react 16.13.11 → 16.13.12

data/lib/lucid_prop_declaration/mixin.rb

@@ -1,126 +1,126 @@
-module LucidPropDeclaration
-  module Mixin
-    if RUBY_ENGINE == 'opal'
-      def self.extended(base)
-        def prop(prop_name, validate_hash = { required: true })
-          validate_hash = validate_hash.to_h if validate_hash.class == Isomorfeus::Props::ValidateHashProxy
-          if validate_hash.key?(:default)
-            %x{
-              if (base.lucid_react_component) {
-                let react_prop_name = Opal.React.lower_camelize(prop_name);
-                #{value = validate_hash[:default]}
-                if (!base.lucid_react_component.defaultProps) { base.lucid_react_component.defaultProps = {}; }
-                base.lucid_react_component.defaultProps[react_prop_name] = value;
-                if (!base.lucid_react_component.propTypes) { base.lucid_react_component.propTypes = {}; }
-                base.lucid_react_component.propTypes[react_prop_name] = base.lucid_react_component.prototype.validateProp;
-              } else if (base.react_component) {
-                let react_prop_name = Opal.React.lower_camelize(prop_name);
-                #{value = validate_hash[:default]}
-                if (!base.react_component.defaultProps) { base.react_component.defaultProps = {}; }
-                base.react_component.defaultProps[react_prop_name] = value;
-                if (!base.react_component.propTypes) { base.react_component.propTypes = {}; }
-                base.react_component.propTypes[react_prop_name] = base.react_component.prototype.validateProp;
-              }
-            }
-          end
-          declared_props[prop_name.to_sym] = validate_hash
-        end
-      end
-
-      def validate_function
-        %x{
-          if (typeof self.validate_function === 'undefined') {
-            self.validate_function = function(props_object) {
-              try { self.$validate_props(Opal.Hash.$new(props_object)) }
-              catch (e) { return e.message; }
-            }
-          }
-          return self.validate_function;
-        }
-      end
-
-      def validate_prop_function(prop)
-        function_name = "validate_#{prop}_function"
-        %x{
-          if (typeof self[function_name] === 'undefined') {
-            self[function_name] = function(value) {
-              try { self.$validate_prop(prop, value); }
-              catch (e) { return e.message; }
-            }
-          }
-          return self[function_name];
-        }
-      end
-    else
-      def prop(prop_name, validate_hash = { required: true })
-        validate_hash = validate_hash.to_h if validate_hash.class == Isomorfeus::Props::ValidateHashProxy
-        declared_props[prop_name.to_sym] = validate_hash
-      end
-    end
-
-    def declared_props
-      @declared_props ||= {}
-    end
-
-    def valid_prop?(prop, value)
-      validate_prop(prop, value)
-    rescue
-      false
-    end
-
-    def valid_props?(props)
-      validate_props(props)
-    rescue
-      false
-    end
-
-    def validate
-      Isomorfeus::Props::ValidateHashProxy.new
-    end
-
-    def validate_prop(prop, value)
-      return false unless declared_props.key?(prop)
-      validator = Isomorfeus::Props::Validator.new(self, prop, value, declared_props[prop])
-      validator.validate!
-      true
-    end
-
-    def validate_props(props)
-      props = {} unless props
-      declared_props.each_key do |prop|
-        if declared_props[prop].key?(:required) && declared_props[prop][:required] && !props.key?(prop)
-          Isomorfeus.raise_error(message: "Required prop #{prop} not given!")
-        end
-      end
-      result = true
-      props.each do |p, v|
-        r = validate_prop(p, v)
-        result = false unless r
-      end
-      result
-    end
-
-    def validated_prop(prop, value)
-      Isomorfeus.raise_error(message: "No such prop #{prop} declared!") unless declared_props.key?(prop)
-      validator = Isomorfeus::Props::Validator.new(self, prop, value, declared_props[prop])
-      validator.validated_value
-    end
-
-    def validated_props(props)
-      props = {} unless props
-
-      declared_props.each_key do |prop|
-        if declared_props[prop].key?(:required) && declared_props[prop][:required] && !props.key?(prop)
-          Isomorfeus.raise_error(message: "Required prop #{prop} not given!")
-        end
-        props[prop] = nil unless props.key?(prop) # let validator handle value
-      end
-
-      result = {}
-      props.each do |p, v|
-        result[p] = validated_prop(p, v)
-      end
-      result
-    end
-  end
-end
+module LucidPropDeclaration
+  module Mixin
+    if RUBY_ENGINE == 'opal'
+      def self.extended(base)
+        def prop(prop_name, validate_hash = { required: true })
+          validate_hash = validate_hash.to_h if validate_hash.class == Isomorfeus::Props::ValidateHashProxy
+          if validate_hash.key?(:default)
+            %x{
+              if (base.lucid_react_component) {
+                let react_prop_name = Opal.React.lower_camelize(prop_name);
+                #{value = validate_hash[:default]}
+                if (!base.lucid_react_component.defaultProps) { base.lucid_react_component.defaultProps = {}; }
+                base.lucid_react_component.defaultProps[react_prop_name] = value;
+                if (!base.lucid_react_component.propTypes) { base.lucid_react_component.propTypes = {}; }
+                base.lucid_react_component.propTypes[react_prop_name] = base.lucid_react_component.prototype.validateProp;
+              } else if (base.react_component) {
+                let react_prop_name = Opal.React.lower_camelize(prop_name);
+                #{value = validate_hash[:default]}
+                if (!base.react_component.defaultProps) { base.react_component.defaultProps = {}; }
+                base.react_component.defaultProps[react_prop_name] = value;
+                if (!base.react_component.propTypes) { base.react_component.propTypes = {}; }
+                base.react_component.propTypes[react_prop_name] = base.react_component.prototype.validateProp;
+              }
+            }
+          end
+          declared_props[prop_name.to_sym] = validate_hash
+        end
+      end
+
+      def validate_function
+        %x{
+          if (typeof self.validate_function === 'undefined') {
+            self.validate_function = function(props_object) {
+              try { self.$validate_props(Opal.Hash.$new(props_object)) }
+              catch (e) { return e.message; }
+            }
+          }
+          return self.validate_function;
+        }
+      end
+
+      def validate_prop_function(prop)
+        function_name = "validate_#{prop}_function"
+        %x{
+          if (typeof self[function_name] === 'undefined') {
+            self[function_name] = function(value) {
+              try { self.$validate_prop(prop, value); }
+              catch (e) { return e.message; }
+            }
+          }
+          return self[function_name];
+        }
+      end
+    else
+      def prop(prop_name, validate_hash = { required: true })
+        validate_hash = validate_hash.to_h if validate_hash.class == Isomorfeus::Props::ValidateHashProxy
+        declared_props[prop_name.to_sym] = validate_hash
+      end
+    end
+
+    def declared_props
+      @declared_props ||= {}
+    end
+
+    def valid_prop?(prop, value)
+      validate_prop(prop, value)
+    rescue
+      false
+    end
+
+    def valid_props?(props)
+      validate_props(props)
+    rescue
+      false
+    end
+
+    def validate
+      Isomorfeus::Props::ValidateHashProxy.new
+    end
+
+    def validate_prop(prop, value)
+      return false unless declared_props.key?(prop)
+      validator = Isomorfeus::Props::Validator.new(self, prop, value, declared_props[prop])
+      validator.validate!
+      true
+    end
+
+    def validate_props(props)
+      props = {} unless props
+      declared_props.each_key do |prop|
+        if declared_props[prop].key?(:required) && declared_props[prop][:required] && !props.key?(prop)
+          Isomorfeus.raise_error(message: "Required prop #{prop} not given!")
+        end
+      end
+      result = true
+      props.each do |p, v|
+        r = validate_prop(p, v)
+        result = false unless r
+      end
+      result
+    end
+
+    def validated_prop(prop, value)
+      Isomorfeus.raise_error(message: "No such prop #{prop} declared!") unless declared_props.key?(prop)
+      validator = Isomorfeus::Props::Validator.new(self, prop, value, declared_props[prop])
+      validator.validated_value
+    end
+
+    def validated_props(props)
+      props = {} unless props
+
+      declared_props.each_key do |prop|
+        if declared_props[prop].key?(:required) && declared_props[prop][:required] && !props.key?(prop)
+          Isomorfeus.raise_error(message: "Required prop #{prop} not given!")
+        end
+        props[prop] = nil unless props.key?(prop) # let validator handle value
+      end
+
+      result = {}
+      props.each do |p, v|
+        result[p] = validated_prop(p, v)
+      end
+      result
+    end
+  end
+end

data/lib/react/children.rb

@@ -1,35 +1,35 @@
-module React
-  module Children
-    class << self
-      def count(children)
-        `Opal.global.React.Children.count(children)`
-      end
-
-      def for_each(children, &block)
-        %x{
-          var fun = function(child) {
-            #{block.call(child)};
-          }
-          Opal.global.React.Children.forEach(children, fun);
-        }
-      end
-
-      def map(children, &block)
-        %x{
-          var fun = function(child) {
-            return #{block.call(child)};
-          }
-          return Opal.global.React.Children.map(children, fun);
-        }
-      end
-
-      def only(children)
-        `Opal.global.React.Children.only(children)`
-      end
-
-      def to_array(children)
-        `Opal.global.React.Children.toArray(children)`
-      end
-    end
-  end
+module React
+  module Children
+    class << self
+      def count(children)
+        `Opal.global.React.Children.count(children)`
+      end
+
+      def for_each(children, &block)
+        %x{
+          var fun = function(child) {
+            #{block.call(child)};
+          }
+          Opal.global.React.Children.forEach(children, fun);
+        }
+      end
+
+      def map(children, &block)
+        %x{
+          var fun = function(child) {
+            return #{block.call(child)};
+          }
+          return Opal.global.React.Children.map(children, fun);
+        }
+      end
+
+      def only(children)
+        `Opal.global.React.Children.only(children)`
+      end
+
+      def to_array(children)
+        `Opal.global.React.Children.toArray(children)`
+      end
+    end
+  end
 end

data/lib/react/component/api.rb

@@ -1,134 +1,134 @@
-module React
-  module Component
-    module Api
-      def self.included(base)
-        base.instance_exec do
-          base_module = base.to_s.deconstantize
-          if base_module != ''
-            base_module.constantize.define_singleton_method(base.to_s.demodulize) do |*args, &block|
-              `Opal.React.internal_prepare_args_and_render(#{base}.react_component, args, block)`
-            end
-          else
-            Object.define_method(base.to_s) do |*args, &block|
-              `Opal.React.internal_prepare_args_and_render(#{base}.react_component, args, block)`
-            end
-          end
-
-          attr_accessor :props
-          attr_accessor :state
-
-          def ref(ref_name, &block)
-            defined_refs.JS[ref_name] = block_given? ? block : `null`
-          end
-
-          def defined_refs
-            @defined_ref ||= `{}`
-          end
-
-          def default_state_defined
-            @default_state_defined
-          end
-
-          def state
-            return @default_state if @default_state
-            @default_state_defined = true
-            %x{
-              var native_state = {state: {}};
-              native_state.setState = function(new_state, callback) {
-                for (var key in new_state) {
-                  this.state[key] = new_state[key];
-                }
-                if (callback) { callback.call(); }
-              }
-            }
-            @default_state = React::Component::State.new(`native_state`)
-          end
-
-          def render(&block)
-            `base.render_block = block`
-          end
-
-          def should_component_update?(&block)
-            `base.should_component_update_block = block`
-          end
-        end
-      end
-
-      def display_name
-        @native.JS[:displayName]
-      end
-
-      def force_update(&block)
-        if block_given?
-          # this maybe needs instance_exec too
-          @native.JS.forceUpdate(`function() { block.$call(); }`)
-        else
-          @native.JS.forceUpdate
-        end
-      end
-
-      def component_fun(class_name, **ruby_props)
-        %x{
-          return function(props) {
-            let outer_props = Opal.React.to_native_react_props(#{ruby_props});
-            let new_props = Object.assign({}, props, outer_props);
-            return Opal.global.React.createElement(#{class_name.constantize}.react_component, new_props)
-          }
-        }
-      end
-
-      def get_react_element(arg, &block)
-        if block_given?
-          # execute block, fetch last element from buffer
-          %x{
-            let last_buffer_length = Opal.React.render_buffer[Opal.React.render_buffer.length - 1].length;
-            let last_buffer_element = Opal.React.render_buffer[Opal.React.render_buffer.length - 1][last_buffer_length - 1];
-            block.$call();
-            // console.log("get_react_element popping", Opal.React.render_buffer, Opal.React.render_buffer.toString())
-            let new_element = Opal.React.render_buffer[Opal.React.render_buffer.length - 1].pop();
-            if (last_buffer_element === new_element) { #{Isomorfeus.raise_error(message: "Block did not create any React element!")} }
-            return new_element;
-          }
-        else
-          # element was rendered before being passed as arg
-          # fetch last element from buffer
-          # `console.log("get_react_element popping", Opal.React.render_buffer, Opal.React.render_buffer.toString())`
-          `Opal.React.render_buffer[Opal.React.render_buffer.length - 1].pop()`
-        end
-      end
-      alias gre get_react_element
-
-      def method_ref(method_symbol, *args)
-        method_key = "#{method_symbol}#{args}"
-        %x{
-          if (#@native.method_refs && #@native.method_refs[#{method_key}]) { return #@native.method_refs[#{method_key}]; }
-          if (!#@native.method_refs) { #@native.method_refs = {}; }
-          #@native.method_refs[#{method_key}] = { m: #{method(method_symbol)}, a: args };
-          return #@native.method_refs[#{method_key}];
-        }
-      end
-      alias m_ref method_ref
-
-      def render_react_element(el)
-        # push el to buffer
-        `Opal.React.render_buffer[Opal.React.render_buffer.length - 1].push(el)`
-        # `console.log("render_react_element pushed", Opal.React.render_buffer, Opal.React.render_buffer.toString())`
-        nil
-      end
-      alias rre render_react_element
-
-      def ref(name)
-        `#@native[name]`
-      end
-
-      def ruby_ref(name)
-        return `#@native[name]` if `(typeof #@native[name] === 'function')`
-        React::Ref::new(`#@native[name]`)
-      end
-
-      def set_state(updater, &callback)
-        @state.set_state(updater, &callback)
-      end
-    end
-  end
-end
+module React
+  module Component
+    module Api
+      def self.included(base)
+        base.instance_exec do
+          base_module = base.to_s.deconstantize
+          if base_module != ''
+            base_module.constantize.define_singleton_method(base.to_s.demodulize) do |*args, &block|
+              `Opal.React.internal_prepare_args_and_render(#{base}.react_component, args, block)`
+            end
+          else
+            Object.define_method(base.to_s) do |*args, &block|
+              `Opal.React.internal_prepare_args_and_render(#{base}.react_component, args, block)`
+            end
+          end
+
+          attr_accessor :props
+          attr_accessor :state
+
+          def ref(ref_name, &block)
+            defined_refs.JS[ref_name] = block_given? ? block : `null`
+          end
+
+          def defined_refs
+            @defined_ref ||= `{}`
+          end
+
+          def default_state_defined
+            @default_state_defined
+          end
+
+          def state
+            return @default_state if @default_state
+            @default_state_defined = true
+            %x{
+              var native_state = {state: {}};
+              native_state.setState = function(new_state, callback) {
+                for (var key in new_state) {
+                  this.state[key] = new_state[key];
+                }
+                if (callback) { callback.call(); }
+              }
+            }
+            @default_state = React::Component::State.new(`native_state`)
+          end
+
+          def render(&block)
+            `base.render_block = #{block}`
+          end
+
+          def should_component_update?(&block)
+            `base.should_component_update_block = block`
+          end
+        end
+      end
+
+      def display_name
+        @native.JS[:displayName]
+      end
+
+      def force_update(&block)
+        if block_given?
+          # this maybe needs instance_exec too
+          @native.JS.forceUpdate(`function() { block.$call(); }`)
+        else
+          @native.JS.forceUpdate
+        end
+      end
+
+      def component_fun(class_name, **ruby_props)
+        %x{
+          return function(props) {
+            let outer_props = Opal.React.to_native_react_props(#{ruby_props});
+            let new_props = Object.assign({}, props, outer_props);
+            return Opal.global.React.createElement(#{class_name.constantize}.react_component, new_props)
+          }
+        }
+      end
+
+      def get_react_element(arg, &block)
+        if block_given?
+          # execute block, fetch last element from buffer
+          %x{
+            let last_buffer_length = Opal.React.render_buffer[Opal.React.render_buffer.length - 1].length;
+            let last_buffer_element = Opal.React.render_buffer[Opal.React.render_buffer.length - 1][last_buffer_length - 1];
+            block.$call();
+            // console.log("get_react_element popping", Opal.React.render_buffer, Opal.React.render_buffer.toString())
+            let new_element = Opal.React.render_buffer[Opal.React.render_buffer.length - 1].pop();
+            if (last_buffer_element === new_element) { #{Isomorfeus.raise_error(message: "Block did not create any React element!")} }
+            return new_element;
+          }
+        else
+          # element was rendered before being passed as arg
+          # fetch last element from buffer
+          # `console.log("get_react_element popping", Opal.React.render_buffer, Opal.React.render_buffer.toString())`
+          `Opal.React.render_buffer[Opal.React.render_buffer.length - 1].pop()`
+        end
+      end
+      alias gre get_react_element
+
+      def method_ref(method_symbol, *args)
+        method_key = "#{method_symbol}#{args}"
+        %x{
+          if (#@native.method_refs && #@native.method_refs[#{method_key}]) { return #@native.method_refs[#{method_key}]; }
+          if (!#@native.method_refs) { #@native.method_refs = {}; }
+          #@native.method_refs[#{method_key}] = { m: #{method(method_symbol)}, a: args };
+          return #@native.method_refs[#{method_key}];
+        }
+      end
+      alias m_ref method_ref
+
+      def render_react_element(el)
+        # push el to buffer
+        `Opal.React.render_buffer[Opal.React.render_buffer.length - 1].push(el)`
+        # `console.log("render_react_element pushed", Opal.React.render_buffer, Opal.React.render_buffer.toString())`
+        nil
+      end
+      alias rre render_react_element
+
+      def ref(name)
+        `#@native[name]`
+      end
+
+      def ruby_ref(name)
+        return `#@native[name]` if `(typeof #@native[name] === 'function')`
+        React::Ref::new(`#@native[name]`)
+      end
+
+      def set_state(updater, &callback)
+        @state.set_state(updater, &callback)
+      end
+    end
+  end
+end

data/lib/react/component/base.rb

@@ -1,9 +1,9 @@
-module React
-  module Component
-    class Base
-      def self.inherited(base)
-        base.include(::React::Component::Mixin)
-      end
-    end
-  end
+module React
+  module Component
+    class Base
+      def self.inherited(base)
+        base.include(::React::Component::Mixin)
+      end
+    end
+  end
 end