hyalite 0.0.1

data/client/hyalite/instance_handles.rb

@@ -0,0 +1,78 @@
+module Hyalite
+  module InstanceHandles
+    @root_index = 0
+
+    SEPARATOR = '.'
+
+    class << self
+      def root_id_string(index)
+        SEPARATOR + index.to_s(36)
+      end
+
+      def create_root_id
+        root_id_string(root_index);
+      end
+
+      def root_id_from_node_id(id)
+        if id && id.start_with?(SEPARATOR)
+          index = id.index(SEPARATOR, 1)
+          index ? id[0...index] : id
+        end
+      end
+
+      def root_index
+        index = @root_index
+        @root_index += 1
+        index
+      end
+
+      def traverse_two_phase(target_id, &cb)
+        traverse_parent_path('', target_id, true, false, &cb)
+        traverse_parent_path(target_id, '', false, true, &cb)
+      end
+
+      def traverse_ancestors(target_id, &cb)
+        traverse_parent_path('', target_id, true, false, &cb)
+      end
+
+      def traverse_parent_path(start, stop, skip_first, skip_last, &cb)
+        start = start || ''
+        stop = stop || ''
+        traverse_up = is_ancestor_id_of(stop, start)
+
+        id = start
+        loop do
+          unless (skip_first && id == start) || (skip_last && id == stop)
+            ret = yield(id, traverse_up)
+          end
+
+          if ret == false || id == stop
+            break
+          end
+
+          id = traverse_up ? parent_id(id) : next_descendant_id(id, stop)
+        end
+      end
+
+      def parent_id(id)
+        id.empty? ? '' : id[0, id.rindex(SEPARATOR)]
+      end
+
+      def is_ancestor_id_of(ancestor_id, descendant_id)
+        descendant_id.index(ancestor_id) == 0 && is_boundary(descendant_id, ancestor_id.length)
+      end
+
+      def is_boundary(id, index)
+        id[index] == SEPARATOR || index == id.length
+      end
+
+      def next_descendant_id(ancestor_id, destination_id)
+        return ancestor_id if ancestor_id == destination_id
+
+        start = ancestor_id.length + SEPARATOR.length
+        last = destination_id.index(SEPARATOR, start) || destination_id.length
+        destination_id[0,last]
+      end
+    end
+  end
+end

data/client/hyalite/internal_component.rb

@@ -0,0 +1,11 @@
+module Hyalite
+  module InternalComponent
+    attr_accessor :mount_index
+
+    def mount_component(root_id, mount_ready, context)
+    end
+
+    def recieve_component(next_element, mount_ready)
+    end
+  end
+end

data/client/hyalite/linked_value_utils.rb

@@ -0,0 +1,27 @@
+module Hyalite
+  module LinkedValueUtils
+    class << self
+      def value(props)
+        if props.has_key? :valueLink
+          props[:valueLink][:value]
+        else
+          props[:value]
+        end
+      end
+
+      def checked(props)
+        if props.has_key? :checkedLink
+          props[:checkedLink][:value]
+        else
+          props[:checked]
+        end
+      end
+
+      def execute_on_change(props, event)
+        if props.has_key? :onChange
+          props[:onChange].call(event)
+        end
+      end
+    end
+  end
+end

data/client/hyalite/mount.rb

@@ -0,0 +1,285 @@
+require 'hyalite/transaction'
+require 'hyalite/adler32'
+require 'hyalite/try'
+require 'hyalite/transaction'
+require 'hyalite/element'
+require 'hyalite/component'
+require 'hyalite/instance_handles'
+require 'hyalite/updates'
+require 'hyalite/composite_component'
+
+module Hyalite
+  module Mount
+    ID_ATTR_NAME = 'data-hyalite-id'
+    CHECKSUM_ATTR_NAME = 'data-react-checksum'
+
+    @instances_by_root_id = {}
+    @containers_by_root_id = {}
+    @is_batching_updates = false
+
+    class << self
+      def instances_by_root_id(root_id)
+        @instances_by_root_id[root_id]
+      end
+
+      def render_subtree_into_container(parent_component, next_element, container, &block)
+        next_wrapped_element = ElementObject.new(TopLevelWrapper, nil, nil, nil, next_element)
+        prev_component = @instances_by_root_id[root_id(container)]
+        if prev_component
+          prev_wrapped_element = prev_component.current_element
+          prev_element = prev_wrapped_element.props;
+          if Reconciler.should_update_component(prev_element, next_element)
+            return update_root_component(
+              prev_component,
+              next_wrapped_element,
+              container,
+              &block
+            ).rendered_component.public_instance
+          else
+            unmount_component_at_node(container)
+          end
+        end
+
+        root_element = root_element_in_container(container)
+        container_has_markup = root_element && is_rendered(root_element)
+        should_reuse_markup = container_has_markup && prev_component.nil?
+
+        component = render_new_root_component(
+          next_wrapped_element,
+          container,
+          should_reuse_markup,
+          parent_component ?
+            parent_component.internal_instance.process_child_context(parent_component.internal_instance.context) :
+            {}
+        ).rendered_component.public_instance
+
+        if block_given?
+          yield component
+        end
+
+        component
+      end
+
+      def is_rendered(node)
+        return false if node.node_type != Browser::DOM::Node::ELEMENT_NODE
+
+        id = node_id(node)
+        id ? id[0] == SEPARATOR : false
+      end
+
+      def render_new_root_component(next_element, container, should_reuse_markup, context)
+        component_instance = Hyalite.instantiate_component(next_element, nil)
+        root_id = register_component(component_instance, container)
+
+        Hyalite.updates.batched_updates do
+          mount_component_into_node(component_instance, root_id, container, should_reuse_markup, context)
+        end
+
+        component_instance
+      end
+
+      def register_component(next_component, container)
+        #ReactBrowserEventEmitter.ensureScrollValueMonitoring();
+
+        root_id = register_container(container)
+        @instances_by_root_id[root_id] = next_component;
+        root_id
+      end
+
+      def register_container(container)
+        root_id = root_id(container)
+        if root_id
+          root_id = InstanceHandles.root_id_from_node_id(root_id)
+        end
+
+        unless root_id
+          root_id = InstanceHandles.create_root_id
+        end
+
+        @containers_by_root_id[root_id] = container
+        root_id
+      end
+
+      def mount_component_into_node(component_instance, root_id, container, should_reuse_markup, context)
+        Hyalite.updates.reconcile_transaction.perform do |transaction|
+          markup = Reconciler.mount_component(component_instance, root_id, transaction.mount_ready, context)
+          component_instance.rendered_component.top_level_wrapper = component_instance
+          mount_image_into_node(markup, container, should_reuse_markup)
+        end
+      end
+
+      def mount_image_into_node(markup, container, should_reuse_markup)
+        if should_reuse_markup
+          root_element = root_element_in_container(container)
+          checksum = Adler32.checksum markup
+          checksum_attr = root_element.attr(CHECKSUM_ATTR_NAME)
+          if checksum == checksum_attr
+            return
+          end
+
+          root_element.remove_attr(CHECKSUM_ATTR_NAME)
+          root_element.attr(CHECKSUM_ATTR_NAME, checksum)
+        end
+
+        container.inner_dom = markup
+      end
+
+      def root_element_in_container(container)
+        if container.node_type == Browser::DOM::Node::DOCUMENT_NODE
+          $document
+        else
+          container.child
+        end
+      end
+
+      def root_id(container)
+        root_element = root_element_in_container(container)
+        root_element && node_id(root_element)
+      end
+
+      def node_cache
+        @node_cache ||= {}
+      end
+
+      def purge_id(id)
+        @node_cache.delete(id)
+      end
+
+      def node_id(node)
+        id = internal_id(node)
+        if id
+          if node_cache.has_key?(id)
+            cached = node_cache[id]
+            if cached != node
+              #raise "Mount: Two valid but unequal nodes with the same `#{ID_ATTR_NAME}`: #{id}"
+              node_cache[id] = node
+            end
+          else
+            node_cache[id] = node
+          end
+        end
+
+        id
+      end
+
+      def internal_id(node)
+        if node.node_type == Browser::DOM::Node::ELEMENT_NODE
+          node.attr(ID_ATTR_NAME)
+        end
+      end
+
+      # cf. ReactMount#findReactContainerForID
+      def container_for_id(id)
+        root_id = InstanceHandles.root_id_from_node_id(id)
+        @containers_by_root_id[root_id]
+      end
+
+      def node(id)
+        node =  node_cache[id]
+        unless node && is_valid(node, id)
+          root_id = InstanceHandles.root_id_from_node_id(id)
+          node = node_cache[id] = find_component_root(@containers_by_root_id[root_id], id)
+        end
+        node
+      end
+
+      def is_valid(node, id)
+        if node
+          container = @containers_by_root_id[id]
+          if container && contains_node(container, node)
+            return true
+          end
+        end
+
+        false
+      end
+
+      def find_component_root(ancestor_node, target_id)
+        deepest_ancestor = find_deepest_cached_ancestor(target_id) || ancestor_node
+
+        first_children = [ deepest_ancestor.child ]
+
+        while first_children.length > 0
+          child = first_children.shift
+
+          while child
+            child_id = node_id(child)
+            if child_id
+              if target_id == child_id
+                return child
+              elsif InstanceHandles.is_ancestor_id_of(child_id, target_id)
+                first_children = [ child.child ]
+              end
+            else
+              first_children.push(child.child)
+            end
+
+            child = child.next_sibling
+          end
+        end
+
+        raise "can't find component_root"
+      end
+
+      def find_deepest_cached_ancestor(target_id)
+        deepest_node_so_far = nil
+        InstanceHandles.traverse_ancestors(target_id) do |ancestor_id|
+          ancestor = node_cache[ancestor_id]
+          if ancestor && is_valid(ancestor, ancestor_id)
+            deepest_node_so_far = ancestor;
+          else
+            false
+          end
+        end
+
+        deepest_node_so_far
+      end
+
+      def contains_node(outer_node, inner_node)
+        case
+        when outer_node.nil? || inner_node.nil?
+          false
+        when outer_node == inner_node
+          true
+        when outer_node.node_type == Browser::DOM::Node::TEXT_NODE
+          false
+        else
+          contains_node(outer_node, inner_node.parent)
+        end
+      end
+
+      def find_first_hyalite_dom(node)
+        while node && node.parent != node
+          unless node.node_type == Browser::DOM::Node::ELEMENT_NODE && node_id = internal_id(node)
+            node = node.parent
+            next
+          end
+
+          root_id = InstanceHandles.root_id_from_node_id(node_id)
+
+          current = node
+          loop do
+            last_id = internal_id(current)
+            return nil unless current = current.parent
+            break if last_id == root_id
+          end
+
+          return node if current == @containers_by_root_id[root_id]
+
+          node = node.parent
+        end
+
+        nil
+      end
+
+      def update_root_component(prev_component, next_element, container, &callback)
+        UpdateQueue.enqueue_element_internal(prev_component, next_element)
+        if block_given?
+          UpdateQueue.enqueue_callback_internal(prev_component, &callback)
+        end
+
+        prev_component
+      end
+    end
+  end
+end

data/client/hyalite/multi_children.rb

@@ -0,0 +1,272 @@
+module Hyalite
+  module MultiChildren
+    def mount_children(nested_children, mount_ready, context)
+      children = instantiate_children(nested_children, mount_ready, context)
+      @rendered_children = children
+      index = 0
+      children.keys.map do |name|
+        child = children[name]
+        root_id = root_node_id + name
+        mount_image = Reconciler.mount_component(children[name], root_id, mount_ready, context)
+        child.mount_index = index
+        index += 1
+        mount_image
+      end
+    end
+
+    def unmount_children
+      if @rendered_children
+        Reconciler.unmount_children(@rendered_children)
+        @rendered_children = nil
+      end
+    end
+
+    def update_children(next_nested_children, mount_ready, context)
+      MultiChildren.wrap_update do
+        prev_children = @rendered_children
+        next_children = Reconciler.update_children(prev_children, next_nested_children, mount_ready, context)
+        @rendered_children = next_children
+        return if next_children.nil? && prev_children.nil?
+
+
+        last_index = 0
+        next_index = 0
+        next_children.each do |name, next_child|
+          prev_child = prev_children && prev_children[name]
+          if prev_child == next_child
+            move_child(prev_child, next_index, last_index)
+            last_index = [prev_child.mount_index, last_index].max
+            prev_child.mount_index = next_index
+          else
+            if prev_child
+              last_index = [prev_child.mount_index, last_index].max
+              unmount_child(prev_child)
+            end
+
+            mount_child_by_name_at_index(next_child, name, next_index, mount_ready, context)
+          end
+          next_index += 1
+        end
+
+        prev_children.each do |name, prev_child|
+          unless next_children && next_children.has_key?(name)
+            unmount_child(prev_child)
+          end
+        end
+      end
+    end
+
+    def update_text_content(next_content)
+      MultiChildren.wrap_update do
+        prev_children = @rendered_children
+        if prev_children
+          Reconciler.unmount_children(prev_children)
+          prev_children.each do |prev_child|
+            unmount_child(prev_child)
+          end
+        end
+        set_text_content(next_content)
+      end
+    end
+
+    def move_child(child, to_index, last_index)
+      if child.mount_index < last_index
+        enqueue_move(root_node_id, child.mount_index, to_index)
+      end
+    end
+
+    def remove_child(child)
+      enqueue_remove(root_node_id, child.mount_index)
+    end
+
+    def unmount_child(child)
+      remove_child(child)
+      child.mount_index = nil
+    end
+
+    def instantiate_children(nested_child_nodes, context)
+      Reconciler.flatten_children(nested_child_nodes).map {|name, child|
+        child_instance = Hyalite.instantiate_component(child, nil)
+        [name, child_instance]
+      }.to_h
+    end
+
+    private
+
+    class << self
+      def wrap_update(&block)
+        self.update_depth += 1
+        error_thrown = false
+        yield
+      ensure
+        self.update_depth -= 1
+        if self.update_depth == 0
+          unless error_thrown
+            self.process_queue
+          else
+            self.clear_queue
+          end
+        end
+      end
+
+      def update_depth
+        @update_depth ||= 0
+      end
+
+      def update_depth=(depth)
+        @update_depth = depth
+      end
+
+      def update_queue
+        @update_queue ||= []
+      end
+
+      def markup_queue
+        @markup_queue ||= []
+      end
+
+      def clear_queue
+        self.update_queue.clear
+        self.markup_queue.clear
+      end
+
+      def process_queue
+        if MultiChildren.update_queue.any?
+          process_children_updates(MultiChildren.update_queue, MultiChildren.markup_queue)
+          clear_queue
+        end
+      end
+
+      def process_children_updates(updates, markup)
+        updates.each do |update|
+          update[:parentNode] = Mount.node(update[:parentID])
+        end
+        process_updates(updates, markup)
+      end
+
+      def process_updates(updates, markup_list)
+        initial_children = {}
+        updated_children = []
+
+        updates.each_with_index do |update, updated_index|
+          if update[:type] == :move_existing || update[:type] == :remove_node
+            updated_index = update[:fromIndex]
+            updated_child = update[:parentNode].elements[updated_index]
+            parent_id = update[:parentID]
+
+            initial_children[parent_id] ||= []
+            initial_children[parent_id] << updated_child
+
+            updated_children << updated_child
+          end
+        end
+
+        if markup_list.any? && markup_list[0].is_a?(String)
+          #rendered_markup = Danger.dangerouslyRenderMarkup(markupList);
+          raise "not implemented"
+        else
+          rendered_markup = markup_list
+        end
+
+        updated_children.each do |child|
+          child.remove
+        end
+
+        updates.each do |update|
+          case update[:type]
+          when :insert_markup
+            insert_child_at(
+              update[:parentNode],
+              rendered_markup[update[:markupIndex]],
+              update[:toIndex])
+          when :move_existing
+            insert_child_at(
+              update[:parentNode],
+              initial_children[update[:parentID]][update[:fromIndex]],
+              update[:toIndex])
+          when :set_markup
+            update[:parentNode].inner_html = update[:textContent]
+          when :text_content
+            update[:parentNode].content = update[:textContent]
+          when :remove_node
+            # Already removed above.
+          end
+        end
+      end
+
+
+      def insert_child_at(parent_node, child_node, index)
+        if index >= parent_node.children.to_ary.length
+          parent_node.add_child(child_node)
+        else
+          parent_node[index].add_previous_sibling(child_node)
+        end
+      end
+    end
+
+    def mount_child_by_name_at_index(child, name, index, mount_ready, context)
+      root_id = root_node_id + name
+      mount_image = Reconciler.mount_component(child, root_id, mount_ready, context)
+      child.mount_index = index
+      create_child(child, mount_image)
+    end
+
+    def create_child(child, mount_image)
+      enqueue_markup(root_node_id, mount_image, child.mount_index)
+    end
+
+    def set_text_content(text_content)
+      enqueue_text_content(root_node_id, text_content)
+    end
+
+    def enqueue_remove(parent_id, from_index)
+      MultiChildren.update_queue << {
+        parentID: parent_id,
+        parentNode: nil,
+        type: :remove_node,
+        markupIndex: nil,
+        content: nil,
+        fromIndex: from_index,
+        toIndex: nil
+      }
+    end
+
+    def enqueue_move(parent_id, from_index, to_index)
+      MultiChildren.update_queue << {
+        parentID: parent_id,
+        parentNode: nil,
+        type: :move_existing,
+        markupIndex: nil,
+        content: nil,
+        fromIndex: from_index,
+        toIndex: to_index
+      }
+    end
+
+    def enqueue_text_content(parent_id, text_content)
+      MultiChildren.update_queue << {
+        parentID: parent_id,
+        parentNode: nil,
+        type: :text_content,
+        markupIndex: nil,
+        textContent: text_content,
+        fromIndex: nil,
+        toIndex: nil
+      }
+    end
+
+    def enqueue_markup(parent_id, markup, to_index)
+      MultiChildren.markup_queue << markup
+      MultiChildren.update_queue << {
+        parentID: parent_id,
+        parentNode: nil,
+        type: :insert_markup,
+        markupIndex: MultiChildren.markup_queue.length - 1,
+        textContent: nil,
+        fromIndex: nil,
+        toIndex: to_index
+      }
+    end
+
+  end
+end