hyalite 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d206b2b8ac5745b538a38390d5969f25a938bee0
+  data.tar.gz: 27970cdf165567fad934301c261f7c9e6b4abf2a
+SHA512:
+  metadata.gz: c0fb1bd06c6e90c252aa874a76e0361136c9dbe0c2f3ff6f48ea2e2027df184daa6b64b2475225bd28f683b59c1be2bc282dbd756c9fb10a14074045f602cb75
+  data.tar.gz: 9bd0d1ea6396e00a98247f8024990ccbc2bbca354cf401c0ead9345720bb9258b7801d26a816f243ab52c2ce0e643d0f3ba8902f7af3dd763b40029eb4a3ad12

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 youchan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+Hyalite
+====
+
+This is ruby virtual DOM implementation using opal. It is inspired by react.js.
+
+Example
+----
+
+```ruby
+require_relative 'hyalite.rb'
+require 'browser/interval'
+
+class ExampleView
+  include Hyalite::Component
+
+  def initial_state
+    @count = 0
+    { now: @count }
+  end
+
+  def component_did_mount
+    every(1) do
+      set_state({ now: @count += 1 })
+    end
+  end
+
+  def render
+    Hyalite.create_element("div", nil,
+      Hyalite.create_element("h2", nil, @props[:title]),
+      Hyalite.create_element("h3", nil, "count = #{@state[:now]}"))
+  end
+end
+
+$document.ready do
+  Hyalite.render(Hyalite.create_element(ExampleView, {title: "Hyalite counter example"}), $document['.container'])
+end
+```
+
+How to execute this example is the following.
+
+```
+> cd example
+> rackup
+```
+
+Open url `http://localhost:9292`.

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/client/hyalite.rb

@@ -0,0 +1,98 @@
+require 'opal'
+require 'browser'
+require 'hyalite/transaction'
+require 'hyalite/adler32'
+require 'hyalite/mount'
+require 'hyalite/element'
+require 'hyalite/dom_component'
+require 'hyalite/text_component'
+
+module Hyalite
+  class << self
+    RESERVED_PROPS = [:key, :ref, :children]
+
+    def create_element(type, config = nil, *children)
+      key = nil
+      ref = nil
+
+      props = {}
+
+      if config
+        key = config[:key]
+        ref = config[:ref]
+
+        config.each do |name, value|
+          unless RESERVED_PROPS.include?(name)
+            props[name] = config[name];
+          end
+        end
+      end
+
+      props[:children] = case children.length
+                         when 0
+                           nil
+                         when 1
+                           children.first
+                         else
+                           children
+                         end
+
+      ElementObject.new(type, key, ref, Hyalite.current_owner, props)
+    end
+
+    def instantiate_component(node)
+      node = EmptyComponent.empty_element if node.nil?
+
+      case node
+      when ElementObject
+        case node.type
+        when String
+          DOMComponent.new node
+        when Class
+          if node.type.include?(InternalComponent)
+            node.type.new
+          elsif node.type.include?(Component)
+            CompositeComponent.new node
+          else
+            raise "Encountered invalid type of Hyalite node. type: #{node.type}"
+          end
+        end
+      when String, Numeric
+        TextComponent.new node
+      when EmptyComponent
+        CompositeComponent.new node
+      else
+        raise "Encountered invalid Hyalite node: #{node}"
+      end
+    end
+
+    def render(next_element, container, &block)
+      Mount.render_subtree_into_container(nil, next_element, container, &block);
+    end
+
+    def instance_map
+      @instance_map ||= {}
+    end
+
+    def current_owner(current_owner = nil)
+      if current_owner && block_given?
+        begin
+          @current_owner = current_owner
+          yield(@current_owner)
+        ensure
+          @current_owner = nil
+        end
+      else
+        @current_owner
+      end
+    end
+
+    def find_dom_node(component_or_element)
+      return component_or_element if component_or_element.respond_to?(:node_type) && component_or_element.node_type == Browser::DOM::Node::ELEMENT_NODE
+
+      if instance_map.has_key?(component_or_element)
+        return Mount.node(instance_map[component_or_element].root_node_id)
+      end
+    end
+  end
+end

data/client/hyalite/adler32.rb

@@ -0,0 +1,33 @@
+module Adler32
+  MOD = 65521
+
+  class << self
+    def calc(*args)
+      a = 1
+      b = 0
+      c = 1000
+
+      args.each do |str|
+        throw ArgumentError, "Only string can be passed: #{str.inspect}:#{str.class}" unless str.is_a? String
+
+        str.each_char do |char|
+          a += char.ord
+          b += a
+          c -= 1
+          if c <= 0
+            a %= MOD
+            b %= MOD
+            c = 1000
+          end
+        end
+      end
+      a %= MOD
+      b %= MOD
+      (b << 16) | a
+    end
+
+    def checksum(*args)
+      "%08x" % calc(*args)
+    end
+  end
+end

data/client/hyalite/browser_event.rb

@@ -0,0 +1,201 @@
+require 'set'
+require 'math'
+require 'hyalite/event_dispatcher'
+require 'hyalite/synthetic_event'
+require 'hyalite/event_plugin/event_plugin_registry'
+require 'hyalite/event_plugin/simple_event_plugin'
+require 'hyalite/event_plugin/change_event_plugin'
+
+module Hyalite
+  module BrowserEvent
+    TOP_EVENT_MAPPING = {
+      topBlur: 'blur',
+      topChange: 'change',
+      topClick: 'click',
+      topCompositionEnd: 'compositionend',
+      topCompositionStart: 'compositionstart',
+      topCompositionUpdate: 'compositionupdate',
+      topContextMenu: 'contextmenu',
+      topCopy: 'copy',
+      topCut: 'cut',
+      topDoubleClick: 'dblclick',
+      topDrag: 'drag',
+      topDragEnd: 'dragend',
+      topDragEnter: 'dragenter',
+      topDragExit: 'dragexit',
+      topDragLeave: 'dragleave',
+      topDragOver: 'dragover',
+      topDragStart: 'dragstart',
+      topDrop: 'drop',
+      topFocus: 'focus',
+      topInput: 'input',
+      topKeyDown: 'keydown',
+      topKeyPress: 'keypress',
+      topKeyUp: 'keyup',
+      topMouseDown: 'mousedown',
+      topMouseMove: 'mousemove',
+      topMouseOut: 'mouseout',
+      topMouseOver: 'mouseover',
+      topMouseUp: 'mouseup',
+      topPaste: 'paste',
+      topScroll: 'scroll',
+      topSelectionChange: 'selectionchange',
+      topTextInput: 'textInput',
+      topTouchCancel: 'touchcancel',
+      topTouchEnd: 'touchend',
+      topTouchMove: 'touchmove',
+      topTouchStart: 'touchstart',
+      topWheel: 'wheel'
+    }
+
+    TOP_LISTENERS_ID_KEY = '_hyliteListenersID' + Math.rand.to_s.chars.drop(2).join
+
+    class << self
+      def enabled?
+        event_dispatcher.enabled?
+      end
+
+      def enabled=(enabled)
+        event_dispatcher.enabled = enabled
+      end
+
+      def event_dispatcher
+        @event_dispatcher ||= EventDispatcher.new do |top_level_type, top_level_target, top_level_target_id, event|
+          event_plugin_registry.extract_events(top_level_type, top_level_target, top_level_target_id, event)
+        end
+      end
+
+      def event_plugin_registry
+        @event_plugin_registry ||= EventPluginRegistry.new(
+          SimpleEventPlugin.new,
+          ChangeEventPlugin.new
+        )
+      end
+
+      def include?(name)
+        event_plugin_registry.include? name
+      end
+
+      def listen_to(registration_name, content_document_handle)
+        mount_at = content_document_handle
+        is_listening = listening_for_document(mount_at)
+        dependencies = event_plugin_registry.dependencies(registration_name)
+
+        dependencies.each do |dependency|
+          unless is_listening[dependency]
+            case dependency
+            when :top_wheel
+              nil
+            #   if isEventSupported('wheel')
+            #     ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
+            #       topLevelTypes.topWheel,
+            #       'wheel',
+            #       mountAt
+            #     );
+            #   elsif isEventSupported('mousewheel')
+            #     ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
+            #       topLevelTypes.topWheel,
+            #       'mousewheel',
+            #       mountAt
+            #     );
+            #   else
+            #     ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
+            #       topLevelTypes.topWheel,
+            #       'DOMMouseScroll',
+            #       mountAt
+            #     );
+            #   end
+            # when :top_scroll
+            #   if isEventSupported('scroll', true)
+            #     ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(
+            #       topLevelTypes.topScroll,
+            #       'scroll',
+            #       mountAt
+            #     );
+            #   else
+            #     ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
+            #       topLevelTypes.topScroll,
+            #       'scroll',
+            #       ReactBrowserEventEmitter.ReactEventListener.WINDOW_HANDLE
+            #     );
+            #   end
+            # when :top_focus, :top_blur
+            #   if isEventSupported('focus', true)
+            #     ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(
+            #       topLevelTypes.topFocus,
+            #       'focus',
+            #       mountAt
+            #     );
+            #     ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(
+            #       topLevelTypes.topBlur,
+            #       'blur',
+            #       mountAt
+            #     );
+            #   elsif isEventSupported('focusin')
+            #     ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
+            #       topLevelTypes.topFocus,
+            #       'focusin',
+            #       mountAt
+            #     );
+            #     ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
+            #       topLevelTypes.topBlur,
+            #       'focusout',
+            #       mountAt
+            #     );
+            #   end
+            #
+            #   is_listening[:top_blur] = true
+            #   is_listening[:top_focus] = true
+            else
+              if TOP_EVENT_MAPPING.has_key? dependency
+                trap_bubbled_event(dependency, TOP_EVENT_MAPPING[dependency], mount_at)
+              end
+            end
+
+            is_listening[dependency] = true
+          end
+        end
+      end
+
+      def put_listener(id, event_name, listener)
+        event_dispatcher.put_listener(id, event_name, listener)
+      end
+
+      def delete_listener(id, registration_name)
+        event_dispatcher.delete_listener(id, registration_name) do |id, registration_name|
+          plugin = event_plugin_registry[registration_name]
+          if plugin.respond_to? :will_delete_listener
+            plugin.will_delete_listener(id, registration_name)
+          end
+        end
+      end
+
+      def delete_all_listeners(id)
+        event_dispatcher.delete_all_listeners(id) do |id, registration_name|
+          plugin = event_plugin_registry[registration_name]
+          if plugin.respond_to? :will_delete_listener
+            plugin.will_delete_listener(id, registration_name)
+          end
+        end
+      end
+
+      def listener_at_phase(id, dispatch_config, propagation_phase)
+        registration_name = dispatch_config[:phasedRegistrationNames][propagation_phase]
+        event_dispatcher.get_listener(id, registration_name)
+      end
+
+      def listening_for_document(mount_at)
+        @already_listening_to ||= []
+        unless `Object.prototype.hasOwnProperty.call(mount_at.native, #{TOP_LISTENERS_ID_KEY})`
+          `mount_at.native[#{TOP_LISTENERS_ID_KEY}] = #{@already_listening_to.length}`
+          @already_listening_to << {}
+        end
+        @already_listening_to[`mount_at.native[#{TOP_LISTENERS_ID_KEY}]`]
+      end
+
+      def trap_bubbled_event(top_level_type, handler_base_name, handle)
+        event_dispatcher.trap_bubbled_event(top_level_type, handler_base_name, handle)
+      end
+    end
+  end
+end

data/client/hyalite/callback_queue.rb

@@ -0,0 +1,22 @@
+class CallbackQueue
+  def initialize
+    @queue = []
+  end
+
+  def enqueue(proc = nil, &block)
+    if proc
+      @queue << proc
+    elsif block_given?
+      @queue << block
+    end
+  end
+
+  def notify_all
+    queue = @queue
+    @queue = []
+    while queue.length > 0
+      proc = queue.shift
+      proc.call
+    end
+  end
+end