opal-browser 0.2.0.beta1 → 0.2.0

data/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/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/opal/browser/dom/mutation_observer.rb

@@ -49,7 +49,7 @@ class MutationObserver
         []
       end
 
-      NodeSet.new($document, array)
+      NodeSet[array]
     end
 
     # @!attribute [r] removed
@@ -61,7 +61,7 @@ class MutationObserver
         []
       end
 
-      NodeSet.new($document, array)
+      NodeSet[array]
     end
 
     # @!attribute [r] target

data/opal/browser/dom/node.rb

@@ -42,16 +42,7 @@ class Node
   #
   # @return [Boolean]
   def ==(other)
-    `#@native === #{Native.try_convert(other)}`
-  end
-
-  # Return true if the node name matches the given name case-insensitively.
-  #
-  # @param name [String] the name to match with
-  #
-  # @return [Boolean]
-  def =~(name)
-    self.name.downcase == name.downcase
+    `#@native === #{Native.convert(other)}`
   end
 
   # Append a child to the node.
@@ -65,36 +56,74 @@ class Node
   #
   # @return [self]
   def <<(node)
-    if native?(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)`
-    elsif node.respond_to? :each
-      node.each { |n| add_child(n) }
-    elsif String === node
-      `#@native.appendChild(#@native.ownerDocument.createTextNode(node))`
     else
-      `#@native.appendChild(#{Native.convert(node)})`
+      `#@native.insertBefore(node, #@native.firstChild)`
     end
 
     self
   end
 
-  alias add_child <<
+  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)
-    if native?(node)
-      `#@native.parentNode.insertBefore(node, #@native.nextSibling)`
-    elsif String === node
-      `#@native.parentNode.insertBefore(
-        #@native.ownerDocument.createTextNode(node), #@native.nextSibling)`
-    else
-      `#@native.parentNode.insertBefore(#{Native.convert(node)},
-        #@native.nextSibling)`
+  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.
@@ -102,15 +131,20 @@ class Node
   # 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)
-    if native?(node)
-      `#@native.parentNode.insertBefore(node, #@native)`
-    elsif String === node
-      `#@native.parentNode.insertBefore(
-        #@native.ownerDocument.createTextNode(node), #@native)`
-    else
-      `#@native.parentNode.insertBefore(#{Native.convert(node)}, #@native)`
+  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
@@ -119,7 +153,7 @@ class Node
   #
   # @param node [Node] the node to append to
   def append_to(node)
-    node.add_child(self)
+    node << self
   end
 
   # Get an array of ancestors.
@@ -130,7 +164,7 @@ class Node
   #
   # @return [NodeSet]
   def ancestors(expression = nil)
-    return NodeSet.new(document) unless parent
+    return NodeSet[] unless parent
 
     parents = [parent]
 
@@ -143,12 +177,10 @@ class Node
     end
 
     if expression
-      parents.select! {|p|
-        p.matches? expression
-      }
+      parents.select! { |p| p =~ expression }
     end
 
-    NodeSet.new document, parents
+    NodeSet.new(parents)
   end
 
   alias before add_previous_sibling
@@ -160,7 +192,7 @@ class Node
 
   # Remove all the children of the node.
   def clear
-    children.each(&:remove)
+    children.remove
   end
 
   # @!attribute content
@@ -209,7 +241,7 @@ class Node
   # @!attribute children
   # @return [NodeSet] the children of the node
   def children
-    NodeSet.new(document, Native::Array.new(`#@native.childNodes`))
+    NodeSet[Native::Array.new(`#@native.childNodes`)]
   end
 
   def children=(node)
@@ -277,13 +309,6 @@ class Node
     element_children.last
   end
 
-  # Check if the node matches the given CSS selector.
-  #
-  # @param expression [String] the CSS selector
-  def matches?(expression)
-    false
-  end
-
   # @!attribute name
   # @return [String] the name of the node
   def name
@@ -339,7 +364,7 @@ class Node
   end
 
   def parent=(node)
-    `#@native.parentNode = #{Native.try_convert(node)}`
+    `#@native.parentNode = #{Native.convert(node)}`
   end
 
   def parse(text, options = {})
@@ -350,6 +375,13 @@ class Node
     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
@@ -384,11 +416,21 @@ class Node
   # @param node [Node] the node to replace with
   # @return [Node] the passed node
   def replace(node)
-    `#@native.parentNode.replaceChild(#@native, #{Native.try_convert(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=
 

data/opal/browser/dom/node_set.rb

@@ -1,25 +1,20 @@
 module Browser; module DOM
 
+# Allows manipulation of a set of {Node}s.
 class NodeSet
-  attr_reader :document
-
-  def initialize(document, list = [])
-    @document = document
-    @literal  = []
-
-    list.each {|el|
-      if NodeSet === el
-        @literal.concat(el.to_a)
-      else
-        @literal.push DOM(Native.convert(el))
-      end
-    }
+  # Create a new {NodeSet} from the given nodes.
+  #
+  # Note that the nodes are flattened and converted with DOM automatically,
+  # this means you can pass {NodeSet}s and {Native::Array}s as well.
+  def self.[](*nodes)
+    new(nodes.flatten.map { |x| DOM(Native.convert(x)) }.uniq)
   end
 
-  def respond_to_missing?(name)
-    @literal.respond_to?(name)
+  def initialize(literal)
+    @literal = literal
   end
 
+  # Any other method will be called on every node in the set.
   def method_missing(name, *args, &block)
     unless @literal.respond_to? name
       each {|el|
@@ -34,58 +29,81 @@ class NodeSet
     if `result === #@literal`
       self
     elsif Array === result
-      NodeSet.new(@document, result)
+      NodeSet.new(result)
     else
       result
     end
   end
 
-  def dup
-    NodeSet.new(document, to_ary.dup)
-  end
-
-  def filter(expression)
-    NodeSet.new(document, @literal.select { |node| node.matches?(expression) })
-  end
-
-  def after(node)
-    last.after node
-  end
-
-  def at(path)
-    raise NotImplementedError
-  end
-
+  # Get the first node matching the given CSS selectors.
+  #
+  # @param rules [Array<String>] the CSS selectors to match with
+  #
+  # @return [Node?]
   def at_css(*rules)
-    raise NotImplementedError
+    each {|node|
+      if node = node.at_css(*rules)
+        return node
+      end
+    }
+
+    nil
   end
 
+  # Get the first node matching the given XPath.
+  #
+  # @param paths [Array<String>] the XPath to match with
+  #
+  # @return [Node?]
   def at_xpath(*paths)
-    raise NotImplementedError
-  end
+    each {|node|
+      if node = node.at_xpath(*paths)
+        return node
+      end
+    }
 
-  def before
-    first.before
+    nil
   end
 
-  def children
-    result = NodeSet.new(document)
-
-    each { |n| result.concat(n.children) }
-
-    result
+  # Query for children matching the given CSS selector.
+  #
+  # @param selector [String] the CSS selector
+  #
+  # @return [NodeSet]
+  def css(path)
+    NodeSet[@literal.map {|node|
+      node.css(path)
+    }]
   end
 
-  def css(*paths)
-    raise NotImplementedError
+  # Create another {NodeSet} with all the nodes that match the given
+  # expression.
+  #
+  # @param expression [String] a CSS selector
+  #
+  # @return [NodeSet] the new {NodeSet} with the matching nodes
+  def filter(expression)
+    @literal.select { |node| node =~ expression }
   end
 
+  # Search for multiple selectors
   def search(*what)
-    map { |n| n.search(*what) }.flatten.uniq
+    NodeSet[@literal.map { |node| node.search(*what) }]
+  end
+
+  # Query for children matching the given XPath.
+  #
+  # @param path [String] the XPath
+  #
+  # @return [NodeSet]
+  def xpath(path)
+    NodeSet[@literal.map {|node|
+      node.xpath(path)
+    }]
   end
 
-  def inspect
-    "#<DOM::NodeSet: #{@literal.inspect[1 .. -2]}"
+  def to_ary
+    @literal
   end
 end
 

data/opal/browser/effects.rb

@@ -1,20 +1,28 @@
 module Browser; module DOM
 
 class Document < Element
+  # @!attribute [r] active_element
+  # @return [Element] the element with focus
   def active_element
     DOM(`#@native.activeElement`)
   end
 end
 
 class Element
+  # Show the element.
+  #
+  # @param what [Symbol] how to display it
   def show(what = :block)
     style[:display] = what
   end
 
+  # Hide the element.
   def hide
     style[:display] = :none
   end
 
+  # Toggle the visibility of the element, hide it if it's shown, show it if
+  # it's hidden.
   def toggle
     if style![:display] == :none
       show
@@ -23,14 +31,17 @@ class Element
     end
   end
 
+  # Set the focus on the element.
   def focus
     `#@native.focus()`
   end
 
+  # Blur the focus from the element.
   def blur
     `#@native.blur()`
   end
 
+  # Check if the element is focused.
   def focused?
     `#@native.hasFocus`
   end