hyalite 0.0.1

data/client/hyalite/dom_operations.rb

@@ -0,0 +1,17 @@
+require 'hyalite/dom_property_operations'
+
+module Hyalite
+  module DOMOperations
+    class << self
+      def update_property_by_id(id, name, value)
+        node = Mount.node(id)
+
+        if value
+          DOMPropertyOperations.set_value_for_property(node, name, value)
+        else
+          DOMPropertyOperations.delete_value_for_property(node, name)
+        end
+      end
+    end
+  end
+end

data/client/hyalite/dom_property.rb

@@ -0,0 +1,218 @@
+module Hyalite
+  module DOMProperty
+    ID_ATTRIBUTE_NAME = 'data-hyalite-id'
+
+    MUST_USE_ATTRIBUTE           = 1
+    MUST_USE_PROPERTY            = 2
+    HAS_BOOLEAN_VALUE            = 4
+    HAS_SIDE_EFFECTS             = 8
+    HAS_NUMERIC_VALUE            = 16
+    HAS_POSITIVE_NUMERIC_VALUE   = 32
+    HAS_OVERLOADED_BOOLEAN_VALUE = 64
+
+    PROPERTIES = {
+      ###############################
+      ### Standard Properties
+      ###############################
+      accept: nil,
+      acceptCharset: nil,
+      accessKey: nil,
+      action: nil,
+      allowFullScreen: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
+      allowTransparency: MUST_USE_ATTRIBUTE,
+      alt: nil,
+      async: HAS_BOOLEAN_VALUE,
+      autoComplete: nil,
+      # autoFocus is polyfilled/normalized by AutoFocusUtils
+      # autoFocus: HAS_BOOLEAN_VALUE,
+      autoPlay: HAS_BOOLEAN_VALUE,
+      capture: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
+      cellPadding: nil,
+      cellSpacing: nil,
+      charSet: MUST_USE_ATTRIBUTE,
+      challenge: MUST_USE_ATTRIBUTE,
+      checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
+      classID: MUST_USE_ATTRIBUTE,
+      className: MUST_USE_PROPERTY,
+      cols: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,
+      colSpan: nil,
+      content: nil,
+      contentEditable: nil,
+      contextMenu: MUST_USE_ATTRIBUTE,
+      controls: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
+      coords: nil,
+      crossOrigin: nil,
+      data: nil, # For `<object />` acts as `src`.
+      dateTime: MUST_USE_ATTRIBUTE,
+      defer: HAS_BOOLEAN_VALUE,
+      dir: nil,
+      disabled: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
+      download: HAS_OVERLOADED_BOOLEAN_VALUE,
+      draggable: nil,
+      encType: nil,
+      form: MUST_USE_ATTRIBUTE,
+      formAction: MUST_USE_ATTRIBUTE,
+      formEncType: MUST_USE_ATTRIBUTE,
+      formMethod: MUST_USE_ATTRIBUTE,
+      formNoValidate: HAS_BOOLEAN_VALUE,
+      formTarget: MUST_USE_ATTRIBUTE,
+      frameBorder: MUST_USE_ATTRIBUTE,
+      headers: nil,
+      height: MUST_USE_ATTRIBUTE,
+      hidden: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
+      high: nil,
+      href: nil,
+      hrefLang: nil,
+      htmlFor: nil,
+      httpEquiv: nil,
+      icon: nil,
+      id: MUST_USE_PROPERTY,
+      inputMode: MUST_USE_ATTRIBUTE,
+      is: MUST_USE_ATTRIBUTE,
+      keyParams: MUST_USE_ATTRIBUTE,
+      keyType: MUST_USE_ATTRIBUTE,
+      label: nil,
+      lang: nil,
+      list: MUST_USE_ATTRIBUTE,
+      loop: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
+      low: nil,
+      manifest: MUST_USE_ATTRIBUTE,
+      marginHeight: nil,
+      marginWidth: nil,
+      max: nil,
+      maxLength: MUST_USE_ATTRIBUTE,
+      media: MUST_USE_ATTRIBUTE,
+      mediaGroup: nil,
+      method: nil,
+      min: nil,
+      minLength: MUST_USE_ATTRIBUTE,
+      multiple: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
+      muted: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
+      name: nil,
+      noValidate: HAS_BOOLEAN_VALUE,
+      open: HAS_BOOLEAN_VALUE,
+      optimum: nil,
+      pattern: nil,
+      placeholder: nil,
+      poster: nil,
+      preload: nil,
+      radioGroup: nil,
+      readOnly: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
+      rel: nil,
+      required: HAS_BOOLEAN_VALUE,
+      role: MUST_USE_ATTRIBUTE,
+      rows: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,
+      rowSpan: nil,
+      sandbox: nil,
+      scope: nil,
+      scoped: HAS_BOOLEAN_VALUE,
+      scrolling: nil,
+      seamless: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
+      selected: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
+      shape: nil,
+      size: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,
+      sizes: MUST_USE_ATTRIBUTE,
+      span: HAS_POSITIVE_NUMERIC_VALUE,
+      spellCheck: nil,
+      src: nil,
+      srcDoc: MUST_USE_PROPERTY,
+      srcSet: MUST_USE_ATTRIBUTE,
+      start: HAS_NUMERIC_VALUE,
+      step: nil,
+      style: nil,
+      tabIndex: nil,
+      target: nil,
+      title: nil,
+      type: nil,
+      useMap: nil,
+      value: MUST_USE_PROPERTY | HAS_SIDE_EFFECTS,
+      width: MUST_USE_ATTRIBUTE,
+      wmode: MUST_USE_ATTRIBUTE,
+
+      ###############################
+      ### Non-standard Properties
+      ###############################
+      # autoCapitalize and autoCorrect are supported in Mobile Safari for
+      # keyboard hints.
+      autoCapitalize: nil,
+      autoCorrect: nil,
+      # itemProp, itemScope, itemType are for
+      # Microdata support. See http:#schema.org/docs/gs.html
+      itemProp: MUST_USE_ATTRIBUTE,
+      itemScope: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
+      itemType: MUST_USE_ATTRIBUTE,
+      # itemID and itemRef are for Microdata support as well but
+      # only specified in the the WHATWG spec document. See
+      # https:#html.spec.whatwg.org/multipage/microdata.html#microdata-dom-api
+      itemID: MUST_USE_ATTRIBUTE,
+      itemRef: MUST_USE_ATTRIBUTE,
+      # property is supported for OpenGraph in meta tags.
+      property: nil,
+      # IE-only attribute that specifies security restrictions on an iframe
+      # as an alternative to the sandbox attribute on IE<10
+      security: MUST_USE_ATTRIBUTE,
+      # IE-only attribute that controls focus behavior
+      unselectable: MUST_USE_ATTRIBUTE,
+    }
+
+    DOM_ATTRIBUTE_NAMES = {
+      acceptCharset: 'accept-charset',
+      className: 'class',
+      htmlFor: 'for',
+      httpEquiv: 'http-equiv'
+    }
+
+    class << self
+      def property_info(name)
+        return nil unless PROPERTIES.has_key? name.to_sym
+
+        @property_info ||= {}
+        unless @property_info.has_key? name
+          property = PROPERTIES[name.to_sym]
+
+          attribute_name = DOM_ATTRIBUTE_NAMES.has_key?(name) ? DOM_ATTRIBUTE_NAMES[name] : name.downcase
+
+          @property_info[name] = {
+            attribute_name: attribute_name,
+            attribute_namespace: nil,
+            property_name: name,
+            mutation_method: nil,
+            must_use_attribute: property && property & MUST_USE_ATTRIBUTE > 0,
+            must_use_property: property && property & MUST_USE_PROPERTY > 0,
+            has_side_effects: property && property & HAS_SIDE_EFFECTS > 0,
+            has_boolean_value: property && property & HAS_BOOLEAN_VALUE > 0,
+            has_numeric_value: property && property & HAS_NUMERIC_VALUE > 0,
+            has_positive_numeric_value: property && property & HAS_POSITIVE_NUMERIC_VALUE > 0,
+            has_overloaded_boolean_value: property && property & HAS_OVERLOADED_BOOLEAN_VALUE > 0
+          }
+        end
+
+        @property_info[name]
+      end
+
+      def include?(name)
+        PROPERTIES.has_key? name
+      end
+
+      def default_value_for_property(node_name, prop)
+        node_defaults = default_value_cache[node_name]
+        unless node_defaults
+          default_value_cache[node_name] = node_defaults = {}
+        end
+        unless node_defaults.include? prop
+          test_element = $document.create_element(node_name)
+          node_defaults[prop] = test_element[prop]
+        end
+        node_defaults[prop]
+      end
+
+      def default_value_cache
+        @default_value_cache ||= {}
+      end
+
+      def is_custom_attribute(attribute_name)
+        /^(data|aria)-[a-z_][a-z\d_.\-]*$/ =~ attribute_name
+      end
+    end
+  end
+end

data/client/hyalite/dom_property_operations.rb

@@ -0,0 +1,117 @@
+require 'hyalite/dom_property'
+require 'hyalite/utils'
+
+module Hyalite
+  module DOMPropertyOperations
+    VALID_ATTRIBUTE_NAME_REGEX = /^[a-zA-Z_][a-zA-Z_\.\-\d]*$/
+
+    class << self
+      def create_markup_for_property(element, name, value)
+        property_info = DOMProperty.property_info(name)
+        if property_info
+          return if should_ignore_value(property_info, value)
+
+          attribute_name = property_info[:attribute_name]
+          if property_info[:has_boolean_value] || property_info[:has_overloaded_boolean_value] && value == true
+            element[attribute_name] = ""
+            return
+          end
+
+          element[attribute_name]=Hyalite.escape_text_content_for_browser(value)
+        elsif DOMProperty.is_custom_attribute(name)
+          return if value.nil?
+
+          element[name]=Hyalite.escape_text_content_for_browser(value)
+        end
+      end
+
+      def create_markup_for_styles(element, styles)
+        element.style(styles)
+      end
+
+      def create_markup_for_custom_attribute(element, name, value)
+        return if (!is_attribute_name_safe(name) || value == null)
+
+        element[name]=Hyalite.escape_text_content_for_browser(value)
+      end
+
+      def is_attribute_name_safe(attribute_name)
+        @illegal_attribute_name_cache ||= {}
+        @validated_attribute_name_cache ||= {}
+
+        return true if @validated_attribute_name_cache.has_key? attribute_name
+        return false if @illegal_attribute_name_cache.has_key? attribute_name
+
+        if VALID_ATTRIBUTE_NAME_REGEX =~ attribute_name
+          @validated_attribute_name_cache[attributeName] = true
+          return true
+        end
+
+        @illegal_attribute_name_cache[attributeName] = true
+        false
+      end
+
+      def set_value_for_property(node, name, value)
+        property_info = DOMProperty.property_info(name)
+        if property_info
+          mutation_method = property_info[:mutation_method]
+          if mutation_method
+            mutation_method.call(node, value);
+          elsif should_ignore_value(property_info, value)
+            delete_value_for_property(node, name)
+          elsif property_info[:must_use_attribute]
+            attribute_name = property_info[:attribute_name]
+            namespace = property_info[:attribute_namespace]
+            if namespace
+              node[attribute_name, {namespace: namespace}] = value.to_s
+            elsif property_info[:has_boolean_value] ||
+                 (property_info[:has_overloaded_boolean_value] && value == true)
+              node[attribute_name] = ''
+            else
+              node[attribute_name] = value.to_s
+            end
+          else
+            prop_name = property_info[:property_name]
+            unless property_info[:has_side_effects] && `'' + node[#{prop_name}]` == value.to_s
+              `node.native[#{prop_name}] = value`
+            end
+          end
+        elsif DOMProperty.is_custom_attribute(name)
+          DOMPropertyOperations.set_value_for_attribute(node, name, value)
+        end
+      end
+
+      def delete_value_for_property(node, name)
+        property_info = DOMProperty.property_info(name)
+        if property_info
+          mutation_method = property_info[:mutation_method]
+          if mutation_method
+            mutation_method.call(node, nil)
+          elsif property_info[:must_use_attribute]
+            node.remove_attribute(property_info[:attribute_name])
+          else
+            prop_name = property_info[:property_name]
+            default_value = DOMProperty.default_value_for_property(node.node_name, prop_name)
+            unless property_info[:has_side_effects] || (node[prop_name].to_s == default_value)
+              node[prop_name] = default_value
+            end
+          end
+        elsif DOMProperty.is_custom_attribute(name)
+          node.remove_attribute(name)
+        end
+      end
+
+      def set_attribute_for_id(node, id)
+        node[DOMProperty::ID_ATTRIBUTE_NAME] = id
+      end
+
+      def should_ignore_value(property_info, value)
+        value.nil? ||
+        (property_info[:has_boolean_value] && !value) ||
+        (property_info[:has_numeric_value] && value.nan?) ||
+        (property_info[:has_positive_numeric_value] && (value < 1)) ||
+        (property_info[:has_overloaded_boolean_value] && value == false)
+      end
+    end
+  end
+end

data/client/hyalite/element.rb

@@ -0,0 +1,17 @@
+module Hyalite
+  class ElementObject
+    attr_reader :type, :key, :ref, :props, :owner
+
+    def initialize(type, key, ref, owner, props)
+      @type = type
+      @key = key
+      @ref = ref
+      @owner = owner
+      @props = props
+    end
+
+    def inspect
+      "<#{type} #{props.inspect} />"
+    end
+  end
+end

data/client/hyalite/event_dispatcher.rb

@@ -0,0 +1,99 @@
+module Hyalite
+  class EventDispatcher
+    def initialize(&extract_events)
+      @enabled = true
+      @listener_bank = {}
+      @extract_events = extract_events
+      @event_queue = []
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def enabled=(enabled)
+      @enabled = enabled
+    end
+
+    def trap_bubbled_event(top_level_type, handler_base_name, element)
+      return nil unless element
+
+      element.on handler_base_name do |event|
+        dispatch_event(top_level_type, event)
+      end
+    end
+
+    def find_parent(node)
+      node_id = Mount.node_id(node)
+      root_id = InstanceHandles.root_id_from_node_id(node_id)
+      container = Mount.container_for_id(root_id)
+      Mount.find_first_hyalite_dom(container)
+    end
+
+    def handle_top_level(book_keeping)
+      ancestor = Mount.find_first_hyalite_dom(book_keeping.event.target)
+      while ancestor
+        book_keeping.ancestors << ancestor
+        ancestor = find_parent(ancestor)
+      end
+
+      book_keeping.ancestors.each do |top_level_target|
+        top_level_target_id = Mount.node_id(top_level_target) || ''
+        synthetic_events = @extract_events.call(
+          book_keeping.top_level_type,
+          top_level_target,
+          top_level_target_id,
+          book_keeping.event,
+        ).flatten
+
+        synthetic_events.each do |synthetic_event|
+          synthetic_event.each_listener do |listener, dom_id|
+            target = Mount.node(dom_id);
+            listener.call(synthetic_event.event, target)
+          end
+        end
+      end
+    end
+
+    def dispatch_event(top_level_type, event)
+      return unless @enabled
+
+      book_keeping = TopLevelCallbackBookKeeping.new(top_level_type, event)
+      Hyalite.updates.batched_updates { handle_top_level(book_keeping) }
+    end
+
+    def put_listener(id, registration_name, listener)
+      listeners = @listener_bank[registration_name] ||= {}
+      listeners[id] = listener
+    end
+
+    def get_listener(id, registration_name)
+      @listener_bank[registration_name].try {|listeners| listeners[id] }
+    end
+
+    def delete_listener(id, registration_name)
+      if @listener_bank.has_key? registration_name
+        yield(id, registration_name)
+        @listener_bank[registration_name].delete(id)
+      end
+    end
+
+    def delete_all_listeners(id, &block)
+      @listener_bank.each do |registration_name, bank|
+        next unless bank[id]
+        yield(id, registration_name) if block_given?
+        bank.delete(id)
+      end
+    end
+
+    class TopLevelCallbackBookKeeping
+      attr_reader :event, :top_level_type, :ancestors
+
+      def initialize(top_level_type, event)
+        @top_level_type = top_level_type
+        @event = event
+        @ancestors = []
+      end
+    end
+  end
+end