hyalite 0.0.1

data/client/hyalite/reconcile_transaction.rb

@@ -0,0 +1,41 @@
+require 'hyalite/transaction'
+
+module Hyalite
+  class ReconcileTransaction < Transaction
+    def initialize
+      @mount_ready_wrapper = MountReadyWrapper.new
+      super [ @mount_ready_wrapper, EventSuppressionWrapper.new ]
+    end
+
+    def mount_ready
+      @mount_ready_wrapper.queue
+    end
+
+    class MountReadyWrapper
+      include TransactionWrapper
+
+      attr_reader :queue
+
+      def initialize
+        @queue = CallbackQueue.new
+      end
+
+      def close
+        @queue.notify_all
+      end
+    end
+
+    class EventSuppressionWrapper
+      include TransactionWrapper
+
+      def initialize
+        @previous_enabled = BrowserEvent.enabled?
+        BrowserEvent.enabled = false
+      end
+
+      def close
+        BrowserEvent.enabled = @previous_enabled
+      end
+    end
+  end
+end

data/client/hyalite/reconciler.rb

@@ -0,0 +1,122 @@
+module Hyalite
+  module Reconciler
+
+    SEPARATOR = '.';
+    SUBSEPARATOR = ':';
+
+    class << self
+      def mount_component(internal_instance, root_id, mount_ready, context)
+        markup = internal_instance.mount_component(root_id, mount_ready, context)
+        if internal_instance.current_element.respond_to?(:ref) && internal_instance.current_element.ref
+          mount_ready.enqueue do
+            internal_instance.current_element.owner.attach_ref(internal_instance.current_element.ref, internal_instance)
+          end
+        end
+        markup
+      end
+
+      def unmount_component(internal_instance)
+        #ReactRef.detachRefs(internalInstance, internalInstance._currentElement);
+        internal_instance.unmount_component
+      end
+
+      def receive_component(internal_instance, next_element, mount_ready, context)
+        prev_element = internal_instance.current_element
+
+        return if next_element == prev_element && internal_instance.respond_to?(:context) && context == internal_instance.context
+
+        # refs_changed = ReactRef.should_update_refs(prev_element, next_element)
+        #
+        # ReactRef.detach_refs(internal_instance, prev_element) if refs_changed
+
+        internal_instance.receive_component(next_element, mount_ready, context)
+
+        # transaction.enqueue(attach_refs, internal_instance) if refs_changed
+      end
+
+      def perform_update_if_necessary(internal_instance, mount_ready)
+        internal_instance.perform_update_if_necessary(mount_ready)
+      end
+
+      def update_children(prev_children, next_nested_child_nodes, mount_ready, context)
+        next_children = flatten_children(next_nested_child_nodes)
+        return nil if next_children.nil? && prev_children.nil?
+
+        next_children.each do |name, next_element|
+          prev_child = prev_children && prev_children[name]
+          prev_element = prev_child && prev_child.current_element
+          if should_update_component(prev_element, next_element)
+            receive_component(prev_child, next_element, mount_ready, context)
+            next_children[name] = prev_child
+          else
+            if prev_child
+              unmount_component(prev_child, name)
+            end
+
+            next_children[name] = Hyalite.instantiate_component(next_element, nil)
+          end
+        end
+
+        prev_children.each do |name, prev_child|
+          unless next_children && next_children.has_key?(name)
+            unmount_component(prev_children[name])
+          end
+        end
+
+        next_children;
+      end
+
+      def flatten_children(nested_child_nodes)
+        {}.tap do |res|
+          traverse_children(nested_child_nodes, "") do |name, child_node|
+            res[name] = child_node if child_node
+          end
+        end
+      end
+
+      def traverse_children(children, name_so_far)
+        children = nil if children == true || children == false
+
+        if children.nil? || children.is_a?(String) || children.is_a?(Numeric)
+          name = name_so_far.empty? ? SEPARATOR + component_key(children, 0) : name_so_far
+          yield [name, children]
+          return 1
+        end
+
+        case children
+        when Array
+          children.each_with_index do |child, i|
+            next_name = (name_so_far.empty? ? SEPARATOR : name_so_far + SUBSEPARATOR) + component_key(child, i)
+            traverse_children(child, next_name) {|n, c| yield [n, c] }
+          end
+        else
+          name = name_so_far.empty? ? SEPARATOR + component_key(children, 0) : name_so_far
+          yield [name, children]
+        end
+      end
+
+      def component_key(component, index)
+        return "$#{component.key}" if component && component.respond_to?(:key) && component.key
+        index.to_s(36)
+      end
+
+      def should_update_component(prev_element, next_element)
+        if prev_element && next_element
+          if prev_element.is_a?(String) || prev_element.is_a?(Numeric)
+            return next_element.is_a?(String) || next_element.is_a?(Numeric)
+          else
+            return prev_element.type == next_element.type && prev_element.key == next_element.key
+          end
+        end
+        false
+      end
+
+      def unmount_children(rendered_children)
+        rendered_children.values.each do |rendered_child|
+          unmount_component(rendered_child)
+        end
+      end
+    end
+
+  end
+end

data/client/hyalite/short_hand.rb

@@ -0,0 +1,23 @@
+module Hyalite
+  module Component
+    module ShortHand
+      TAGS = %w(h1 h2 h3 h4 h5 h6 header footer section div p span code strong a img input button label ul li)
+
+      def self.included(klass)
+        TAGS.each do |tag|
+          define_method(tag) do |props, *children|
+            Hyalite.create_element(tag, props, *children)
+          end
+        end
+
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        def el(props, *children)
+          Hyalite.create_element(self, props, *children)
+        end
+      end
+    end
+  end
+end

data/client/hyalite/synthetic_event.rb

@@ -0,0 +1,18 @@
+module Hyalite
+  class SyntheticEvent
+    attr_reader :event
+
+    def initialize(event)
+      @event = event
+      @listeners = []
+    end
+
+    def add_listener(listener, target_id)
+      @listeners << [listener, target_id]
+    end
+
+    def each_listener(&block)
+      @listeners.each {|listener| yield(listener) }
+    end
+  end
+end

data/client/hyalite/text_component.rb

@@ -0,0 +1,42 @@
+require 'hyalite/internal_component'
+
+module Hyalite
+  class TextComponent
+    include InternalComponent
+
+    def initialize(text)
+      @text = text
+    end
+
+    def current_element
+      @text
+    end
+
+    def mount_component(root_id, mount_ready, context)
+      @root_node_id = root_id
+      @native_node = $document.create_element('span').tap do |node|
+        DOMPropertyOperations.set_attribute_for_id(node, root_id)
+        Mount.node_id(node)
+        node.text = @text
+      end
+    end
+
+    def unmount_component
+      @native_node = nil
+      Mount.purge_id(@root_node_id)
+    end
+
+    def receive_component(next_text, mount_ready)
+      if next_text != @text
+        @text = next_text
+        node.text = @text
+      end
+    end
+
+    private
+
+    def node
+      @node ||= Mount.node(@root_node_id)
+    end
+  end
+end

data/client/hyalite/transaction.rb

@@ -0,0 +1,47 @@
+module TransactionWrapper
+  def init
+  end
+
+  def close
+  end
+end
+
+class Transaction
+  include TransactionWrapper
+
+  def initialize(transaction_wrappers = nil, &block)
+    @transaction_wrappers = transaction_wrappers || []
+    if block_given?
+      @close_proc = block
+      @transaction_wrappers << self
+    end
+  end
+
+  def close
+    if @close_proc
+      @close_proc.call
+    else
+      close_all
+    end
+  end
+
+  def close_all
+    @transaction_wrappers.each do |wrapper|
+      wrapper.close
+    end
+  end
+
+  def init_all
+    @transaction_wrappers.each do |wrapper|
+      wrapper.init
+    end
+  end
+
+  def perform
+    init_all
+
+    yield(self)
+  ensure
+    close_all
+  end
+end

data/client/hyalite/try.rb

@@ -0,0 +1,7 @@
+class Object
+  def try
+    unless self.nil?
+      yield self
+    end
+  end
+end

data/client/hyalite/update_queue.rb

@@ -0,0 +1,52 @@
+module Hyalite
+  class UpdateQueue
+    class << self
+      def is_mounted(public_instance)
+        internal_instance = Hyalite.instance_map[public_instance]
+        if internal_instance
+          !!internal_instance.rendered_component
+        else
+          false
+        end
+      end
+
+      def enqueue_callback(public_instance, &block)
+        internal_instance = Hyalite.instance_map[public_instance]
+        return nil unless internal_instance
+
+        internal_instance.pending_callbacks ||= []
+        internal_instance.pending_callbacks << block
+        enqueue_update(internal_instance);
+      end
+
+      def enqueue_set_state(public_instance, partial_state)
+        internal_instance = Hyalite.instance_map[public_instance]
+
+        return unless internal_instance
+
+        queue = internal_instance.pending_state_queue || (internal_instance.pending_state_queue = [])
+        queue.push(partial_state)
+
+        enqueue_update(internal_instance);
+      end
+
+      def enqueue_update(internal_instance)
+        Hyalite.updates.enqueue_update(internal_instance)
+      end
+
+      def enqueue_element_internal(internal_instance, new_element)
+        internal_instance.pending_element = new_element
+        enqueue_update(internal_instance)
+      end
+
+      def enqueue_callback_internal(internal_instance, &callback)
+        if internal_instance.pending_callbacks
+          internal_instance.pending_callbacks << callback
+        else
+          internal_instance.pending_callbacks = [callback]
+        end
+        enqueue_update(internal_instance)
+      end
+    end
+  end
+end

data/client/hyalite/updates.rb

@@ -0,0 +1,129 @@
+require 'hyalite/transaction'
+require 'hyalite/callback_queue'
+require 'hyalite/reconciler'
+require 'hyalite/reconcile_transaction'
+
+module Hyalite
+  class Updates
+    class NestedUpdate
+      include TransactionWrapper
+
+      def initialize(dirty_components)
+        @dirty_components = dirty_components
+      end
+
+      def init
+        @init_length = @dirty_components.length
+      end
+
+      def close
+        if @dirty_components.length - @init_length > 0
+          @dirty_components.shift(@init_length)
+        else
+          @dirty_components.clear
+        end
+      end
+    end
+
+    class UpdateQueueing
+      include TransactionWrapper
+
+      def initialize(queue)
+        @queue = queue
+      end
+
+      def close
+        @queue.notify_all
+      end
+    end
+
+    attr_reader :reconcile_transaction
+
+    def initialize
+      @dirty_components = []
+
+      @is_batching_updates = false
+
+      @callback_queue = CallbackQueue.new
+      @asap_callback_queue = CallbackQueue.new
+      @asap_enqueued = false
+      @reconcile_transaction = ReconcileTransaction.new
+
+      @flush_transaction = Transaction.new([NestedUpdate.new(@dirty_components), UpdateQueueing.new(@callback_queue), @reconcile_transaction])
+    end
+
+    def enqueue_update(component)
+      unless @is_batching_updates
+        batched_updates do
+          enqueue_update(component)
+        end
+      end
+
+      @dirty_components << component
+    end
+
+    def batched_updates
+      already_batching_updates = @is_batching_updates
+
+      @is_batching_updates = true
+
+
+      if already_batching_updates
+        yield
+      else
+        transaction = Transaction.new do
+          flush_batched_updates
+          @is_batching_updates = false
+        end
+
+        transaction.perform do
+          yield
+        end
+      end
+    end
+
+    def flush_batched_updates
+      while @dirty_components.length > 0 || @asap_enqueued
+        if @dirty_components.length > 0
+          @flush_transaction.perform do |transaction|
+            run_batched_updates(transaction)
+          end
+        end
+
+        if @asap_enqueued
+          @asap_enqueued = false
+          @asap_callback_queue.notify_all
+          next
+        end
+      end
+    end
+
+    def run_batched_updates(transaction)
+      @dirty_components.sort{|c1, c2| c1.mount_order <=> c2.mount_order}.each do |component|
+        callbacks = component.pending_callbacks
+        component.pending_callbacks = nil
+
+        Reconciler.perform_update_if_necessary(component, @reconcile_transaction.mount_ready)
+
+        if callbacks
+          callbacks.each do |callback|
+            @callback_queue.enqueue(callback)
+          end
+        end
+      end
+    end
+
+    def asap(&callback)
+      @asap_callback_queue.enqueue(&callback)
+      @asap_enqueued = true
+    end
+
+    def mount_ready
+      @reconcile_transaction.mount_ready
+    end
+  end
+
+  def self.updates
+    @updates ||= Updates.new
+  end
+end