isomorfeus-preact 23.1.0.rc1 → 23.6.0.rc1

data/ext/isomorfeus_preact_ext/vnode.c

@@ -1,21 +1,25 @@
 #include <ruby.h>
+#undef DEPRECATED
 #define FIO_MEMORY_NAME vnode
 #include "fio-stl.h"
-#include "isomorfeus_preact_ext.h"
+#include "vnode.h"
 
 VALUE cVNode;
 
 static void preact_vnode_mark(void *p) {
-    VNode *v = (VNode *)p;
-    rb_gc_mark(v->component);
-    rb_gc_mark(v->key);
-    rb_gc_mark(v->props);
-    rb_gc_mark(v->ref);
-    rb_gc_mark(v->type);
+  VNode *v = (VNode *)p;
+  rb_gc_mark(v->component);
+  rb_gc_mark(v->key);
+  rb_gc_mark(v->props);
+  rb_gc_mark(v->ref);
+  rb_gc_mark(v->type);
 }
 
-static void preact_vnode_free(void *p) {
-  vnode_free(p);
+VNode *vnode_emalloc(void) {
+  VNode *v = vnode_malloc(sizeof(VNode));
+  if (v == NULL)
+    rb_raise(rb_eNoMemError, "failed allocation of VNode");
+  return v;
 }
 
 static size_t preact_vnode_size(const void *p) {
@@ -23,26 +27,23 @@ static size_t preact_vnode_size(const void *p) {
   (void)p;
 }
 
-const rb_data_type_t preact_vnode_t = {
-  .wrap_struct_name = "VNode",
-  .function = {
-    .dmark = preact_vnode_mark,
-    .dfree = preact_vnode_free,
-    .dsize = preact_vnode_size,
-    .dcompact = NULL,
-    .reserved = {0}
-  },
-  .parent = NULL,
-  .data = NULL,
-  .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
+const rb_data_type_t preact_vnode_t = {.wrap_struct_name = "VNode",
+                                       .function = {.dmark = preact_vnode_mark,
+                                                    .dfree = vnode_free,
+                                                    .dsize = preact_vnode_size,
+                                                    .dcompact = NULL,
+                                                    .reserved = {0}},
+                                       .parent = NULL,
+                                       .data = NULL,
+                                       .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
 static VALUE preact_vnode_alloc(VALUE rclass) {
-  void *v = vnode_malloc(sizeof(VNode));
-  return TypedData_Wrap_Struct(rclass, &preact_vnode_t, v);
+  return TypedData_Wrap_Struct(rclass, &preact_vnode_t,
+                               vnode_emalloc());
 }
 
-static VALUE preact_vnode_init(VALUE self, VALUE type, VALUE props, VALUE key, VALUE ref) {
+static VALUE preact_vnode_init(VALUE self, VALUE type, VALUE props, VALUE key,
+                               VALUE ref) {
   VNode *v = (VNode *)DATA_PTR(self);
   v->component = Qnil;
   v->key = key;
@@ -53,9 +54,7 @@ static VALUE preact_vnode_init(VALUE self, VALUE type, VALUE props, VALUE key, V
 }
 
 static VALUE preact_vnode_set_c(VALUE self, VALUE c) {
-  VNode *v = (VNode *)DATA_PTR(self);
-  v->component = c;
-  return c;
+  return ((VNode *)DATA_PTR(self))->component = c;
 }
 
 static VALUE preact_vnode_get_c(VALUE self) {

data/ext/isomorfeus_preact_ext/vnode.h

@@ -0,0 +1,9 @@
+#include <ruby.h>
+
+typedef struct VNode {
+  VALUE component;
+  VALUE key;
+  VALUE props;
+  VALUE ref;
+  VALUE type;
+} VNode;

data/lib/isomorfeus/preact/version.rb

@@ -1,5 +1,5 @@
 module Isomorfeus
   module Preact
-    VERSION = '23.1.0.rc1'
+    VERSION = '23.6.0.rc1'
   end
 end

data/lib/isomorfeus/props/validator.rb

@@ -1,169 +1,169 @@
-module Isomorfeus
-  module Props
-    class Validator
-      def initialize(source_class, prop, value, options)
-        @c = source_class
-        @p = prop
-        @v = value
-        @o = options
-      end
-
-      def validate!
-        ensured = ensure!
-        unless ensured
-          set_default_value
-          cast!
-          type!
-        end
-        run_checks!
-        true
-      end
-
-      def validated_value
-        validate!
-        @v
-      end
-
-      private
-
-      # basic tests
-
-      def set_default_value
-        return unless @v.nil?
-        @v = @o[:default] if @o.key?(:default)
-      end
-
-      def cast!
-        if @o.key?(:cast)
-          begin
-            return if @o[:is_a] && @v.is_a?(@o[:is_a])
-            return if @o[:class] && @v.class == @o[:class]
-            if @o[:type] == :boolean
-              @v = !!@v
-              return
-            end
-            cl = @o[:is_a] || @o[:class]
-            @v = case cl.name
-                 when 'Integer' then @v.to_i
-                 when 'String' then @v.to_s
-                 when 'Float' then @v.to_f
-                 when 'Array' then @v.to_a
-                 when 'Hash' then @v.to_h
-                 else
-                  Isomorfeus.raise_error(message: "#{@c}: Dont know how to cast #{@p} to #{cl}!")
-                 end
-          rescue
-            Isomorfeus.raise_error(message: "#{@c}: #{@p} cast to #{cl} failed!")
-          end
-        end
-      end
-
-      def ensure!
-        if @o.key?(:ensure)
-          proc_or_val = @o[:ensure]
-          if proc_or_val.class == Proc
-            @v = proc_or_val.call(@v)
-          else
-            @v = proc_or_val
-          end
-          true
-        else
-          false
-        end
-      end
-
-      def type!
-        return if @o[:allow_nil] && @v.nil?
-        if @o.key?(:class)
-          Isomorfeus.raise_error(message: "#{@c}: #{@p} class is not #{@o[:class]}") unless @v.class == @o[:class]
-        elsif @o.key?(:is_a)
-          Isomorfeus.raise_error(message: "#{@c}: #{@p} is not a #{@o[:is_a]}") unless @v.is_a?(@o[:is_a])
-        elsif @o.key?(:type)
-          case @o[:type]
-          when :boolean
-            Isomorfeus.raise_error(message: "#{@c}: #{@p} is not a boolean") unless @v.class == TrueClass || @v.class == FalseClass
-          else
-            c_string_sub_types
-          end
-        end
-      end
-
-      # all other checks
-
-      def run_checks!
-        if @o.key?(:validate)
-          @o[:validate].each do |m, l|
-            send('c_' + m, l)
-          end
-        end
-        @o[:validate_block].call(@v) if @o.key?(:validate_block)
-      end
-
-      # specific validations
-      def c_gt(v)
-        Isomorfeus.raise_error(message: "#{@c}: #{@p} not greater than #{v}!") unless @v > v
-      end
-
-      def c_lt(v)
-        Isomorfeus.raise_error(message: "#{@c}: #{@p} not less than #{v}!") unless @v < v
-      end
-
-      def c_keys(v)
-        Isomorfeus.raise_error(message: "#{@c}: #{@p} keys dont fit!") unless @v.keys.sort == v.sort
-      end
-
-      def c_size(v)
-        Isomorfeus.raise_error(message: "#{@c}: #{@p} length/size is not #{v}") unless @v.length == v
-      end
-
-      def c_matches(v)
-        Isomorfeus.raise_error(message: "#{@c}: #{@p} does not match #{v}") unless v.match?(@v)
-      end
-
-      def c_max(v)
-        Isomorfeus.raise_error(message: "#{@c}: #{@p} is larger than #{v}") unless @v <= v
-      end
-
-      def c_min(v)
-        Isomorfeus.raise_error(message: "#{@c}: #{@p} is smaller than #{v}") unless @v >= v
-      end
-
-      def c_max_size(v)
-        Isomorfeus.raise_error(message: "#{@c}: #{@p} is larger than #{v}") unless @v.length <= v
-      end
-
-      def c_min_size(v)
-        Isomorfeus.raise_error(message: "#{@c}: #{@p} is smaller than #{v}") unless @v.length >= v
-      end
-
-      def c_direction(v)
-        Isomorfeus.raise_error(message: "#{@c}: #{@p} is positive") if v == :negative && @v >= 0
-        Isomorfeus.raise_error(message: "#{@c}: #{@p} is negative") if v == :positive && @v < 0
-      end
-
-      def c_test
-        Isomorfeus.raise_error(message: "#{@c}: #{@p} test condition check failed") unless @o[:test].call(@v)
-      end
-
-      def c_string_sub_types
-        Isomorfeus.raise_error(message: "#{@c}: #{@p} must be a String") unless @v.class == String
-        case @o[:type]
-        when :email
-          Isomorfeus.raise_error(message: "#{@c}: #{@p} is not a valid email address") unless @v.match?(/\A[^@\s]+@([^@\s]+\.)+[^@\s]+\z/)
-        when :uri
-          if RUBY_ENGINE == 'opal'
-            %x{
-              try {
-                new URL(#@v);
-              } catch {
-                #{Isomorfeus.raise_error(message: "#{@c}: #{@p} is not a valid uri")}
-              }
-            }
-          else
-            Isomorfeus.raise_error(message: "#{@c}: #{@p} is not a valid uri") unless @v.match?(/\A#{URI.regexp}\z/)
-          end
-        end
-      end
-    end
-  end
-end
+module Isomorfeus
+  module Props
+    class Validator
+      def initialize(source_class, prop, value, options)
+        @c = source_class
+        @p = prop
+        @v = value
+        @o = options
+      end
+
+      def validate!
+        ensured = ensure!
+        unless ensured
+          set_default_value
+          cast!
+          type!
+        end
+        run_checks!
+        true
+      end
+
+      def validated_value
+        validate!
+        @v
+      end
+
+      private
+
+      # basic tests
+
+      def set_default_value
+        return unless @v.nil?
+        @v = @o[:default] if @o.key?(:default)
+      end
+
+      def cast!
+        if @o.key?(:cast)
+          begin
+            return if @o[:is_a] && @v.is_a?(@o[:is_a])
+            return if @o[:class] && @v.class == @o[:class]
+            if @o[:type] == :boolean
+              @v = !!@v
+              return
+            end
+            cl = @o[:is_a] || @o[:class]
+            @v = case cl.name
+                 when 'Integer' then @v.to_i
+                 when 'String' then @v.to_s
+                 when 'Float' then @v.to_f
+                 when 'Array' then @v.to_a
+                 when 'Hash' then @v.to_h
+                 else
+                  Isomorfeus.raise_error(message: "#{@c}: Dont know how to cast #{@p} to #{cl}!")
+                 end
+          rescue
+            Isomorfeus.raise_error(message: "#{@c}: #{@p} cast to #{cl} failed!")
+          end
+        end
+      end
+
+      def ensure!
+        if @o.key?(:ensure)
+          proc_or_val = @o[:ensure]
+          if proc_or_val.class == Proc
+            @v = proc_or_val.call(@v)
+          else
+            @v = proc_or_val
+          end
+          true
+        else
+          false
+        end
+      end
+
+      def type!
+        return if @o[:allow_nil] && @v.nil?
+        if @o.key?(:class)
+          Isomorfeus.raise_error(message: "#{@c}: #{@p} class is not #{@o[:class]}") unless @v.class == @o[:class]
+        elsif @o.key?(:is_a)
+          Isomorfeus.raise_error(message: "#{@c}: #{@p} is not a #{@o[:is_a]}") unless @v.is_a?(@o[:is_a])
+        elsif @o.key?(:type)
+          case @o[:type]
+          when :boolean
+            Isomorfeus.raise_error(message: "#{@c}: #{@p} is not a boolean") unless @v.class == TrueClass || @v.class == FalseClass
+          else
+            c_string_sub_types
+          end
+        end
+      end
+
+      # all other checks
+
+      def run_checks!
+        if @o.key?(:validate)
+          @o[:validate].each do |m, l|
+            send('c_' + m, l)
+          end
+        end
+        @o[:validate_block].call(@v) if @o.key?(:validate_block)
+      end
+
+      # specific validations
+      def c_gt(v)
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} not greater than #{v}!") unless @v > v
+      end
+
+      def c_lt(v)
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} not less than #{v}!") unless @v < v
+      end
+
+      def c_keys(v)
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} keys dont fit!") unless @v.keys.sort == v.sort
+      end
+
+      def c_size(v)
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} length/size is not #{v}") unless @v.length == v
+      end
+
+      def c_matches(v)
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} does not match #{v}") unless v.match?(@v)
+      end
+
+      def c_max(v)
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} is larger than #{v}") unless @v <= v
+      end
+
+      def c_min(v)
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} is smaller than #{v}") unless @v >= v
+      end
+
+      def c_max_size(v)
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} is larger than #{v}") unless @v.length <= v
+      end
+
+      def c_min_size(v)
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} is smaller than #{v}") unless @v.length >= v
+      end
+
+      def c_direction(v)
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} is positive") if v == :negative && @v >= 0
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} is negative") if v == :positive && @v < 0
+      end
+
+      def c_test
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} test condition check failed") unless @o[:test].call(@v)
+      end
+
+      def c_string_sub_types
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} must be a String") unless @v.class == String
+        case @o[:type]
+        when :email
+          Isomorfeus.raise_error(message: "#{@c}: #{@p} is not a valid email address") unless @v.match?(/\A[^@\s]+@([^@\s]+\.)+[^@\s]+\z/)
+        when :uri
+          if RUBY_ENGINE == 'opal'
+            %x{
+              try {
+                new URL(#@v);
+              } catch {
+                #{Isomorfeus.raise_error(message: "#{@c}: #{@p} is not a valid uri")}
+              }
+            }
+          else
+            Isomorfeus.raise_error(message: "#{@c}: #{@p} is not a valid uri") unless @v.match?(/\A#{URI.regexp}\z/)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/preact.rb

@@ -53,6 +53,7 @@ module Preact
       const EMPTY_OBJ = {};
       const EMPTY_ARR = [];
       const slice = EMPTY_ARR.slice;
+      const isArray = Array.isArray;
 
       function assign(obj, props) {
         for (let i in props) obj[i] = props[i];
@@ -278,7 +279,7 @@ module Preact
               null,
               str
             );
-          } else if (Array.isArray(childVNode)) {
+          } else if (isArray(childVNode)) {
             childVNode = newParentVNode._children[i] = self.createVNode(
               Opal.Fragment,
               #{{ children: `childVNode` }},
@@ -438,11 +439,11 @@ module Preact
       }
 
       function eventProxy(e) {
-        this._listeners[e.type + false].$call(#{Browser::Event.new(`e`)});
+        this._listeners[e.type + false].$call(#{::Browser::Event.new(`e`)});
       }
 
       function eventProxyCapture(e) {
-        this._listeners[e.type + true].$call(#{Browser::Event.new(`e`)});
+        this._listeners[e.type + true].$call(#{::Browser::Event.new(`e`)});
       }
 
       const IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;
@@ -533,6 +534,8 @@ module Preact
             // cast to `0` instead
             name !== 'tabIndex' &&
             name !== 'download' &&
+            name !== 'rowSpan' &&
+            name !== 'colSpan' &&
             name in dom
           ) {
             try {
@@ -542,18 +545,18 @@ module Preact
             } catch (e) {}
           }
 
-          // ARIA-attributes have a different notion of boolean values.
-          // The value `false` is different from the attribute not
-          // existing on the DOM, so we can't remove it. For non-boolean
-          // ARIA-attributes we could treat false as a removal, but the
-          // amount of exceptions would cost us too many bytes. On top of
-          // that other VDOM frameworks also always stringify `false`.
+          // aria- and data- attributes have no boolean representation.
+          // A `false` value is different from the attribute not being
+          // present, so we can't remove it. For non-boolean aria
+          // attributes we could treat false as a removal, but the
+          // amount of exceptions would cost too many bytes. On top of
+          // that other frameworks generally stringify `false`.
 
           if (typeof value === 'function') {
             // never serialize functions as attribute values
           } else if (
             value != null && value !== nil &&
-            (value !== false || (name[0] === 'a' && name[1] === 'r'))
+            (value !== false || (name[4] === '-'))
           ) {
             dom.setAttribute(name, value);
           } else {
@@ -688,7 +691,7 @@ module Preact
             i = newVNode.props["$[]"]("children");
             diffChildren(
               dom,
-              Array.isArray(i) ? i : [i],
+              isArray(i) ? i : [i],
               newVNode,
               oldVNode,
               globalContext,
@@ -895,7 +898,7 @@ module Preact
 
             diffChildren(
               parentDom,
-              Array.isArray(renderResult) ? renderResult : [renderResult],
+              isArray(renderResult) ? renderResult : [renderResult],
               newVNode,
               oldVNode,
               globalContext,
@@ -970,7 +973,7 @@ module Preact
       }
 
       let vnodeId = 0;
-      const vnode_class = #{VNode};
+      const vnode_class = #{::VNode};
 
       function is_a_vnode(type) { return type === vnode_class; }
       function is_nil() { return false; }
@@ -1116,9 +1119,10 @@ module Preact
       self.process._rerenderCount = 0;
     }
   else
-    IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|^--/i
+    IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|^--/i.freeze
     JS_TO_CSS = {}
-    ENCODED_ENTITIES = /[&<>"]/
+    ENCODED_ENTITIES = /[&<>"]/.freeze
+    ENTITY_REPLACEMENTS = { '&'.freeze => '&amp;'.freeze, '<'.freeze => '&lt;'.freeze, '>'.freeze => '&gt;'.freeze, '"'.freeze => '&quot;'.freeze }.freeze
   end
 
   class << self
@@ -1156,19 +1160,19 @@ module Preact
       if RUBY_ENGINE == 'opal'
         `self.createVNode(vnode.type, normalized_props, #{key || `vnode.key`}, #{ref || `vnode.ref`}, null)`
       else
-        VNode.new(vnode.type, normalized_props, key || vnode.key, ref || vnode.ref)
+        ::VNode.new(vnode.type, normalized_props, key || vnode.key, ref || vnode.ref)
       end
     end
 
     def create_context(const_name, default_value = nil)
-      context = Preact::Context.new(default_value)
-      Object.const_set(const_name, context)
+      context = ::Preact::Context.new(default_value)
+      ::Object.const_set(const_name, context)
     end
 
     def _init_render
       self.render_buffer = []
       self.rerender_queue = []
-      Isomorfeus.reset_something_loading
+      ::Isomorfeus.reset_something_loading
     end
 
     if RUBY_ENGINE == 'opal'
@@ -1244,7 +1248,7 @@ module Preact
           return `document.body.querySelector(element_or_query)`
         elsif `(typeof element_or_query === 'function')`
           return element_or_query
-        elsif element_or_query.is_a?(Browser::Element)
+        elsif element_or_query.is_a?(::Browser::Element)
           return element_or_query.to_n
         else
           return element_or_query
@@ -1264,44 +1268,24 @@ module Preact
       end
     else # RUBY_ENGINE
       def render_buffer
-        Thread.current[:@_isomorfeus_preact_render_buffer]
+        ::Thread.current[:@_isomorfeus_preact_render_buffer]
       end
 
       def render_buffer=(i)
-        Thread.current[:@_isomorfeus_preact_render_buffer] = i
+        ::Thread.current[:@_isomorfeus_preact_render_buffer] = i
       end
 
       def rerender_queue
-        Thread.current[:@_isomorfeus_preact_rerender_queue]
+        ::Thread.current[:@_isomorfeus_preact_rerender_queue]
       end
 
       def rerender_queue=(i)
-        Thread.current[:@_isomorfeus_preact_rerender_queue] = i
-      end
-
-      def is_renderable?(block_result)
-        block_result &&
-          (block_result.is_a?(VNode) || block_result.is_a?(String) || block_result.is_a?(Numeric) ||
-            (block_result.is_a?(Array) && block_result.length > 0 && is_renderable?(block_result[0])))
+        ::Thread.current[:@_isomorfeus_preact_rerender_queue] = i
       end
 
       def _encode_entities(input)
-        s = input.to_s
-        return s unless ENCODED_ENTITIES.match?(s)
-        # TODO performance maybe, maybe similar to new js way, need to measure
-        # for (; i<str.length; i++) {
-        #   switch (str.charCodeAt(i)) {
-        #     case 60: ch = '&lt;'; break;
-        #     case 62: ch = '&gt;'; break;
-        #     case 34: ch = '&quot;'; break;
-        #     case 38: ch = '&amp;'; break;
-        #     default: continue;
-        #   }
-        #   if (i > start) out += str.slice(start, i);
-        #   out += ch;
-        #   start = i + 1;
-        # }
-        s.gsub(/&/, '&amp;').gsub(/</, '&lt;').gsub(/>/, '&gt;').gsub(/"/, '&quot;')
+        return input unless input.match?(ENCODED_ENTITIES)
+        input.gsub(ENCODED_ENTITIES, ENTITY_REPLACEMENTS)
       end
 
       def _style_obj_to_css(v)
@@ -1320,16 +1304,9 @@ module Preact
         return str.empty? ? nil : str
       end
 
-      def _render_element(element, props, &block)
-        pr = Preact.render_buffer
-        pr[pr.length-1] << create_element(element, props, nil, &block)
-        nil
-      end
-
       def render_to_string(vnode, context = nil)
         _init_render
-        context = {} unless context
-        _render_to_string(vnode, context, false, nil)
+        _render_to_string(vnode, context)
       end
     end # RUBY_ENGINE
   end