diamonds 0.1.5

data/lib/diamonds/opal/browser/dom/element/select.rb

@@ -0,0 +1,36 @@
+module Browser; module DOM; class Element < Node
+
+class Select < Element
+  def value
+    %x{
+      if (#@native.value == "") {
+        return nil;
+      }
+      else {
+        return #@native.value;
+      }
+    }
+  end
+
+  def labels
+    NodeSet[Native::Array.new(`#@native.labels`)]
+  end
+
+  def options
+    NodeSet[Native::Array.new(`#@native.options`)]
+  end
+
+  def option
+    DOM(`#@native.options[#@native.selectedIndex]`)
+  end
+
+  def index
+    `#@native.selectedIndex`
+  end
+
+  alias_native :multiple?, :multiple
+  alias_native :required?, :required
+  alias_native :length
+end
+
+end; end; end

data/lib/diamonds/opal/browser/dom/element/size.rb

@@ -0,0 +1,34 @@
+module Browser; module DOM; class Element < Node
+
+class Size
+  attr_reader :element
+
+  # @private
+  def initialize(element, *inc)
+    @element = element
+    @native  = element.to_n
+    @include = inc
+  end
+
+  # @!attribute width
+  # @return [Integer] the element width
+  def width
+    `#@native.offsetWidth`
+  end
+
+  def width=(value)
+    @element.style[:width] = value
+  end
+
+  # @!attribute height
+  # @return [Integer] the element height
+  def height
+    `#@native.offsetHeight`
+  end
+
+  def height=(value)
+    @element.style[:height] = value
+  end
+end
+
+end; end; end

data/lib/diamonds/opal/browser/dom/element/template.rb

@@ -0,0 +1,9 @@
+module Browser; module DOM; class Element < Node
+
+class Template < Element
+  def content
+    DOM(`#@native.content`)
+  end
+end
+
+end; end; end

data/lib/diamonds/opal/browser/dom/element/textarea.rb

@@ -0,0 +1,24 @@
+module Browser; module DOM; class Element < Node
+
+class Textarea < Element
+  def value
+    %x{
+      if (#@native.value == "") {
+        return nil;
+      }
+      else {
+        return #@native.value;
+      }
+    }
+  end
+
+  def value=(value)
+    `#@native.value = #{value}`
+  end
+
+  def clear
+    `#@native.value = ''`
+  end
+end
+
+end; end; end

data/lib/diamonds/opal/browser/dom/mutation_observer.rb

@@ -0,0 +1,178 @@
+module Browser; module DOM
+
+# A {MutationObserver} is a performant way to observe changes in the DOM,
+# either on the tree, the attributes or data.
+#
+# @see https://developer.mozilla.org/en/docs/Web/API/MutationObserver
+class MutationObserver
+  def self.supported?
+    Browser.supports? :MutationObserver
+  end
+
+  include Native
+
+  # Encapsulates a recorded change.
+  class Record
+    include Native
+
+    # @!attribute [r] type
+    # @return [:attributes, :tree, :cdata] the type of the recorded change
+    def type
+      case `#@native.type`
+      when :attributes    then :attribute
+      when :childList     then :tree
+      when :characterData then :cdata
+      end
+    end
+
+    # Returns true if the change happened on attributes.
+    def attribute?
+      type == :attribute
+    end
+
+    # Returns true if the change happened on the tree.
+    def tree?
+      type == :tree
+    end
+
+    # Returns true if the change happened in a CDATA section.
+    def cdata?
+      type == :cdata
+    end
+
+    # @!attribute [r] added
+    # @return [NodeSet] the added nodes
+    def added
+      array = if `#@native.addedNodes != null`
+        Native::Array.new(`#@native.addedNodes`)
+      else
+        []
+      end
+
+      NodeSet[array]
+    end
+
+    # @!attribute [r] removed
+    # @return [NodeSet] the removed nodes
+    def removed
+      array = if `#@native.removedNodes != null`
+        Native::Array.new(`#@native.removedNodes`)
+      else
+        []
+      end
+
+      NodeSet[array]
+    end
+
+    # @!attribute [r] target
+    # @return [Node] the node the mutation affected
+    def target
+      DOM(`#@native.target`)
+    end
+
+    # @!attribute [r] old
+    # @return [String] the old value
+    alias_native :old, :oldValue
+
+    # @!attribute [r] name
+    # @return [String] the name of the attribute
+    alias_native :name, :attributeName
+
+    # @!attribute [r] namespace
+    # @return [String] the namespace of the attribute
+    alias_native :namespace, :attributeNamespace
+  end
+
+  # Create a new MutationObserver with the given block.
+  #
+  # @yieldparam records [Array<Record>] the recorded changes
+  def initialize(&block)
+    %x{
+      var func = function(records) {
+        return #{block.call(`records`.map { |r| Browser::DOM::MutationObserver::Record.new(r) })};
+      }
+    }
+
+    super(`new window.MutationObserver(func)`)
+  end
+
+  # Observe the given target with the given options.
+  #
+  # The supported options are:
+  #
+  # + **children** - whether to observe changes on the children
+  #   of the target or not
+  # + **tree** - whether to observe changes on the whole subtree
+  #   or not
+  # + **attributes** - whether to observe changes to attributes or not,
+  #   if the value is `:old` the old value will be saved
+  # + **cdata** - whether to observe changes to CDATA sections or not,
+  #   if the value is `:old` the old value will be saved
+  # + **filter** - array of attribute names to observe
+  #
+  # @param target [DOM::Node, native] the node to observe
+  # @param options [Hash?] the options
+  def observe(target, options = nil)
+    unless options
+      options = {
+        children:   true,
+        tree:       true,
+        attributes: :old,
+        cdata:      :old
+      }
+    end
+
+    `#@native.observe(#{Native.convert(target)}, #{convert(options)})`
+
+    self
+  end
+
+  # Empty the observer queue and return its contents.
+  #
+  # @return [Array<Record>]
+  def take
+    `#@native.takeRecords()`.map { |r| Record.new(r) }
+  end
+
+  # Disconnect the observer, thus stopping observing any changes.
+  def disconnect
+    `#@native.disconnect()`
+  end
+
+private
+  def convert(hash)
+    options = Native(`{}`)
+
+    if hash[:children]
+      options[:childList] = true
+    end
+
+    if hash[:tree]
+      options[:subtree] = true
+    end
+
+    if attrs = hash[:attributes]
+      options[:attributes] = true
+
+      if attrs == :old
+        options[:attributeOldValue] = true
+      end
+    end
+
+    if filter = hash[:filter]
+      options[:attributeFilter] = filter
+    end
+
+    if cdata = hash[:cdata]
+      options[:characterData] = true
+
+      if cdata == :old
+        options[:characterDataOldValue] = true
+      end
+    end
+
+    options.to_n
+  end
+end
+
+end; end

data/lib/diamonds/opal/browser/dom/node.rb

@@ -0,0 +1,464 @@
+module Browser; module DOM
+
+# Abstract class for all DOM node types.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/Node
+class Node
+  include Native
+
+  ELEMENT_NODE                = 1
+  ATTRIBUTE_NODE              = 2
+  TEXT_NODE                   = 3
+  CDATA_SECTION_NODE          = 4
+  ENTITY_REFERENCE_NOCE       = 5
+  ENTITY_NODE                 = 6
+  PROCESSING_INSTRUCTION_NODE = 7
+  COMMENT_NODE                = 8
+  DOCUMENT_NODE               = 9
+  DOCUMENT_TYPE_NODE          = 10
+  DOCUMENT_FRAGMENT_NODE      = 11
+  NOTATION_NODE               = 12
+
+  # Wrap a native DOM node.
+  #
+  # @param value [native] the native DOM node
+  #
+  # @return [Node]
+  def self.new(value)
+    if self == Node
+      @classes ||= [nil, Element, Attribute, Text, CDATA, nil, nil, nil, Comment, Document, nil, DocumentFragment]
+
+      if klass = @classes[`value.nodeType`]
+        klass.new(value)
+      else
+        raise ArgumentError, 'cannot instantiate a non derived Node object'
+      end
+    else
+      super
+    end
+  end
+
+  # Return true of the other element is the same underlying DOM node.
+  #
+  # @return [Boolean]
+  def ==(other)
+    `#@native === #{Native.convert(other)}`
+  end
+
+  # Append a child to the node.
+  #
+  # When passing a {String} a text node will be created.
+  #
+  # When passing an Object that responds to #each, every yielded element
+  # will be added following the same logic.
+  #
+  # @param node [String, Node, #each, #to_n] the node to append
+  #
+  # @return [self]
+  def <<(node)
+    if Opal.respond_to? node, :each
+      node.each { |n| self << n }
+      return self
+    end
+
+    unless native?(node)
+      if String === node
+        node = `#@native.ownerDocument.createTextNode(node)`
+      else
+        node = Native.convert(node)
+      end
+    end
+
+    `#@native.appendChild(node)`
+
+    self
+  end
+
+  def >>(node)
+    if Opal.respond_to? node, :each
+      node.each { |n| self >> n }
+      return self
+    end
+
+    unless native?(node)
+      if String === node
+        node = `#@native.ownerDocument.createTextNode(node)`
+      else
+        node = Native.convert(node)
+      end
+    end
+
+    if `#@native.firstChild == null`
+      `#@native.appendChild(node)`
+    else
+      `#@native.insertBefore(node, #@native.firstChild)`
+    end
+
+    self
+  end
+
+  def add_child(node = nil, &block)
+    unless node
+      node = DOM(&block)
+    end
+
+    self << node
+  end
+
+  # Add the passed node after this one.
+  #
+  # When passing a {String} a text node will be created.
+  #
+  # @param node [String, Node, #to_n] the node to add
+  def add_next_sibling(node = nil, &block)
+    unless node
+      node = DOM(&block)
+    end
+
+    unless native?(node)
+      if String === node
+        node = `#@native.ownerDocument.createTextNode(node)`
+      else
+        node = Native.convert(node)
+      end
+    end
+
+    `#@native.parentNode.insertBefore(node, #@native.nextSibling)`
+  end
+
+  # Add the passed node before this one.
+  #
+  # When passing a {String} a text node will be created.
+  #
+  # @param node [String, Node, #to_n] the node to add
+  def add_previous_sibling(node = nil, &block)
+    unless node
+      node = DOM(&block)
+    end
+
+    unless native?(node)
+      if String === node
+        node = `#@native.ownerDocument.createTextNode(node)`
+      else
+        node = Native.convert(node)
+      end
+    end
+
+    `#@native.parentNode.insertBefore(node, #@native)`
+  end
+
+  alias after add_next_sibling
+
+  # Append the node to the passed one.
+  #
+  # @param node [Node] the node to append to
+  def append_to(node)
+    node << self
+  end
+
+  # Get an array of ancestors.
+  #
+  # Passing a selector will select the ancestors matching it.
+  #
+  # @param expression [String] the selector to use as filter
+  #
+  # @return [NodeSet]
+  def ancestors(expression = nil)
+    return NodeSet[] unless parent
+
+    parents = [parent]
+
+    while parent = parents.last.parent
+      parents << parent
+    end
+
+    if Document === parents.last
+      parents.pop
+    end
+
+    if expression
+      parents.select! { |p| p =~ expression }
+    end
+
+    NodeSet.new(parents)
+  end
+
+  alias before add_previous_sibling
+
+  # Remove the node from its parent.
+  def remove
+    parent.remove_child(self) if parent
+  end
+
+  # Remove all the children of the node.
+  def clear
+    children.remove
+  end
+
+  # @!attribute content
+  # @return [String] the inner text content of the node
+  if Browser.supports? 'Element.textContent'
+    def content
+      `#@native.textContent`
+    end
+
+    def content=(value)
+      `#@native.textContent = #{value}`
+    end
+  elsif Browser.supports? 'Element.innerText'
+    def content
+      `#@native.innerText`
+    end
+
+    def content=(value)
+      `#@native.innerText = #{value}`
+    end
+  else
+    def content
+      raise NotImplementedError, 'node text content unsupported'
+    end
+
+    def content=(value)
+      raise NotImplementedError, 'node text content unsupported'
+    end
+  end
+
+  def blank?
+    raise NotImplementedError
+  end
+
+  # Return true if the node is a CDATA section.
+  def cdata?
+    node_type == CDATA_SECTION_NODE
+  end
+
+  # @!attribute [r] child
+  # @return [Node?] the first child of the node
+  def child
+    children.first
+  end
+
+  # @!attribute children
+  # @return [NodeSet] the children of the node
+  def children
+    NodeSet[Native::Array.new(`#@native.childNodes`)]
+  end
+
+  def children=(node)
+    raise NotImplementedError
+  end
+
+  # Return true if the node is a comment.
+  def comment?
+    node_type == COMMENT_NODE
+  end
+
+  # @!attribute [r] document
+  # @return [Document?] the document the node is attached to
+  def document
+    DOM(`#@native.ownerDocument`) if defined?(`#@native.ownerDocument`)
+  end
+
+  # Return true if the node is a document.
+  def document?
+    node_type == DOCUMENT_NODE
+  end
+
+  # Return true if the node is an element.
+  def elem?
+    node_type == ELEMENT_NODE
+  end
+
+  alias element? elem?
+
+  # @!attribute [r] element_children
+  # @return [NodeSet] all the children which are elements
+  def element_children
+    children.select(&:element?)
+  end
+
+  alias elements element_children
+
+  # @!attribute [r] first_element_child
+  # @return [Element?] the first element child
+  def first_element_child
+    element_children.first
+  end
+
+  # Return true if the node is a document fragment.
+  def fragment?
+    node_type == DOCUMENT_FRAGMENT_NODE
+  end
+
+  # @!attribute inner_html
+  # @return [String] the inner HTML of the node
+  def inner_html
+    `#@native.innerHTML`
+  end
+
+  def inner_html=(value)
+    `#@native.innerHTML = #{value}`
+  end
+
+  alias inner_text content
+  alias inner_text= content=
+
+  # @!attribute [r] last_element_child
+  # @return [Element?] the last element child
+  def last_element_child
+    element_children.last
+  end
+
+  # @!attribute name
+  # @return [String] the name of the node
+  def name
+    `#@native.nodeName || nil`
+  end
+
+  def name=(value)
+    `#@native.nodeName = #{value.to_s}`
+  end
+
+  # @!attribute [r] namespace
+  # @return [String] the namespace of the node
+  def namespace
+    `#@native.namespaceURI || nil`
+  end
+
+  # @!attribute next
+  # @return [Node?] the next sibling of the node
+  def next
+    DOM(`#@native.nextSibling`) if `#@native.nextSibling != null`
+  end
+
+  alias next= add_next_sibling
+
+  # @!attribute [r] next_element
+  # @return [Element?] the next element sibling of the node
+  def next_element
+    current = self.next
+
+    while current && !current.element?
+      current = current.next
+    end
+
+    current
+  end
+
+  alias next_sibling next
+
+  alias node_name name
+
+  alias node_name= name=
+
+  # @!attribute [r] node_type
+  # @return [Symbol] the type of the node
+  def node_type
+    `#@native.nodeType`
+  end
+
+  # @!attribute parent
+  # @return [Element?] the parent of the node
+  def parent
+    DOM(`#@native.parentNode`) if `#@native.parentNode != null`
+  end
+
+  def parent=(node)
+    `#@native.parentNode = #{Native.convert(node)}`
+  end
+
+  def parse(text, options = {})
+    raise NotImplementedError
+  end
+
+  def path
+    raise NotImplementedError
+  end
+
+  # Prepend the node to the passed one.
+  #
+  # @param node [Node] the node to prepend to
+  def prepend_to(node)
+    node >> self
+  end
+
+  # @!attribute previous
+  # @return [Node?] the previous sibling of the node
+  def previous
+    DOM(`#@native.previousSibling`) if `#@native.previousSibling != null`
+  end
+
+  alias previous= add_previous_sibling
+
+  # @!attribute [r] previous_element
+  # @return [Element?] the previous element sibling of the node
+  def previous_element
+    current = self.previous
+
+    while current && !current.element?
+      current = current.previous
+    end
+
+    current
+  end
+
+  alias previous_sibling previous
+
+  # Remove the given node from the children of this node.
+  def remove_child(node)
+    `#@native.removeChild(#{Native.try_convert(node)})`
+  end
+
+  # Replace the node with the given one.
+  #
+  # @todo implement for NodeSet
+  #
+  # @param node [Node] the node to replace with
+  # @return [Node] the passed node
+  def replace(node)
+    unless native?(node)
+      if String === node
+        node = `#@native.ownerDocument.createTextNode(node)`
+      else
+        node = Native.convert(node)
+      end
+    end
+
+    `#@native.parentNode.replaceChild(node, #@native)`
+
+    node
+  end
+
+  alias replace_with replace
+
+  alias text content
+  alias text= content=
+
+  # Return true if the node is a text node.
+  def text?
+    node_type == TEXT_NODE
+  end
+
+  def traverse(&block)
+    raise NotImplementedError
+  end
+
+  alias type node_type
+
+  # @!attribute value
+  # @return [String] the value of the node
+  def value
+    `#@native.nodeValue || nil`
+  end
+
+  def value=(value)
+    `#@native.nodeValue = value`
+  end
+
+  # @private
+  def inspect
+    "#<DOM::Node: #{name}>"
+  end
+end
+
+end; end