opal-browser 0.1.0.beta1

data/opal/browser/dom/event/page_transition.rb

@@ -0,0 +1,21 @@
+module Browser; module DOM; class Event
+
+class PageTransition < Event
+  def self.supported?
+    not $$[:PageTransitionEvent].nil?
+  end
+
+  class Definition < Definition
+    def persisted=(value)
+      `#@native.persisted = #{value}`
+    end
+  end
+
+  def self.create(name, &block)
+    new(`new PageTransitionEvent(#{name}, #{Definition.new(&block)})`)
+  end
+
+  alias_native :persisted?, :persisted
+end
+
+end; end; end

data/opal/browser/dom/event/pop_state.rb

@@ -0,0 +1,21 @@
+module Browser; module DOM; class Event
+
+class PopState < Event
+  def self.supported?
+    not $$[:PopStateEvent].nil?
+  end
+
+  class Definition < Definition
+    def state=(value)
+      `#@native.state = #{value}`
+    end
+  end
+
+  def self.create(name, &block)
+    new(`new PopStateEvent(#{name}, #{Definition.new(&block)})`)
+  end
+
+  alias_native :state
+end
+
+end; end; end

data/opal/browser/dom/event/progress.rb

@@ -0,0 +1,31 @@
+module Browser; module DOM; class Event
+
+class Progress < Event
+  def self.supported?
+    not $$[:ProgressEvent].nil?
+  end
+
+  class Definition < Definition
+    def computable=(value)
+      `#@native.computableLength = #{value}`
+    end
+
+    def loaded=(value)
+      `#@native.loaded = #{value}`
+    end
+
+    def total=(value)
+      `#@native.total = #{value}`
+    end
+  end
+
+  def self.create(name, &block)
+    new(`new ProgressEvent(#{name}, #{Definition.new(&block)})`)
+  end
+
+  alias_native :computable?, :computableLength
+  alias_native :loaded
+  alias_native :total
+end
+
+end; end; end

data/opal/browser/dom/event/sensor.rb

@@ -0,0 +1,13 @@
+module Browser; module DOM; class Event
+
+class Sensor < Event
+  def self.supported?
+    not $$[:SensorEvent].nil?
+  end
+
+  def self.create(name, &block)
+    new(`new SensorEvent(#{name}, #{Definition.new(&block)})`)
+  end
+end
+
+end; end; end

data/opal/browser/dom/event/storage.rb

@@ -0,0 +1,41 @@
+module Browser; module DOM; class Event
+
+class Storage < Event
+  def self.supported?
+    not $$[:StorageEvent].nil?
+  end
+
+  class Definition < Definition
+    def key=(value)
+      `#@native.key = #{value}`
+    end
+
+    def new=(value)
+      `#@native.newValue = #{value}`
+    end
+
+    def old=(value)
+      `#@native.oldValue = #{value}`
+    end
+
+    def area=(value)
+      `#@native.storageArea = #{value}`
+    end
+
+    def url=(value)
+      `#@native.url = #{value}`
+    end
+  end
+
+  def self.create(name, &block)
+    new(`new StorageEvent(#{name}, #{Definition.new(&block)})`)
+  end
+
+  alias_native :key
+  alias_native :new, :newValue
+  alias_native :old, :oldValue
+  alias_native :area, :storageArea
+  alias_native :url
+end
+
+end; end; end

data/opal/browser/dom/event/touch.rb

@@ -0,0 +1,69 @@
+module Browser; module DOM; class Event
+
+class Touch < Event
+  def self.supported?
+    not $$[:TouchEvent].nil?
+  end
+
+  class Definition < Definition
+    def alt!
+      `#@native.altKey = true`
+    end
+
+    def ctrl!
+      `#@native.ctrlKey = true`
+    end
+
+    def meta!
+      `#@native.metaKey = true`
+    end
+
+    def shift!
+      `#@native.shiftKey = true`
+    end
+  end
+
+  def self.create(name, &block)
+    new(`new TouchEvent(#{name}, #{Definition.new(&block)})`)
+  end
+
+  def alt?
+    `#@native.altKey`
+  end
+
+  def ctrl?
+    `#@native.ctrlKey`
+  end
+
+  def meta?
+    `#@native.metaKey`
+  end
+
+  def shift?
+    `#@native.shiftKey`
+  end
+
+  # TODO: implement touches and targetTouches
+
+  def cancel?
+    name.downcase == 'touchcancel'
+  end
+
+  def end?
+    name.downcase == 'touchend'
+  end
+
+  def leave?
+    name.downcase == 'touchleave'
+  end
+
+  def move?
+    name.downcase == 'touchmove'
+  end
+
+  def start?
+    name.downcase == 'touchstart'
+  end
+end
+
+end; end; end

data/opal/browser/dom/event/ui.rb

@@ -0,0 +1,22 @@
+module Browser; module DOM; class Event
+
+class UI < Event
+  class Definition < Definition
+    def detail=(value)
+      `#@native.detail = #{value}`
+    end
+
+    def view=(value)
+      `#@native.view = #{value}`
+    end
+  end
+
+  def self.create(name, &block)
+    new(`new UIEvent(#{name}, #{Definition.new(&block)})`)
+  end
+
+  alias_native :detail
+  alias_native :view
+end
+
+end; end; end

data/opal/browser/dom/event/wheel.rb

@@ -0,0 +1,49 @@
+module Browser; module DOM; class Event
+
+class Wheel < UI
+  def self.supported?
+    not $$[:WheelEvent].nil?
+  end
+
+  class Definition < Definition
+    def x=(value)
+      `#@native.deltaX = #{value}`
+    end
+
+    def y=(value)
+      `#@native.deltaY = #{value}`
+    end
+
+    def z=(value)
+      `#@native.deltaZ = #{value}`
+    end
+
+    def mode=(value)
+      value = case value
+        when :pixel then `WheelEvent.DOM_DELTA_PIXEL`
+        when :line  then `WheelEvent.DOM_DELTA_LINE`
+        when :page  then `WheelEvent.DOM_DELTA_PAGE`
+      end
+
+      `#@native.deltaMode = #{value}`
+    end
+  end
+
+  def self.create(name, &block)
+    new(`new WheelEvent(#{name}, #{Definition.new(&block)})`)
+  end
+
+  alias_native :x, :deltaX
+  alias_native :y, :deltaY
+  alias_native :z, :deltaZ
+
+  def mode
+    case `#@native.deltaMode`
+      when `WheelEvent.DOM_DELTA_PIXEL` then :pixel
+      when `WheelEvent.DOM_DELTA_LINE`  then :line
+      when `WheelEvent.DOM_DELTA_PAGE`  then :page
+    end
+  end
+end
+
+end; end; end

data/opal/browser/dom/mutation_observer.rb

@@ -0,0 +1,118 @@
+module Browser; module DOM
+
+class MutationObserver
+  include Native
+
+  class Record
+    include Native
+
+    def type
+      case `#@native.type`
+      when :attributes    then :attributes
+      when :childList     then :tree
+      when :characterData then :cdata
+      end
+    end
+
+    def attributes?; type == :attributes; end
+    def tree?;       type == :tree;       end
+    def cdata?;      type == :cdata;      end
+
+    def added
+      array = if `#@native.addedNodes != null`
+        Native::Array.new(`#@native.addedNodes`)
+      else
+        []
+      end
+
+      NodeSet.new($document, array)
+    end
+
+    def removed
+      array = if `#@native.removedNodes != null`
+        Native::Array.new(`#@native.removedNodes`)
+      else
+        []
+      end
+
+      NodeSet.new($document, array)
+    end
+
+    def target
+      DOM(`#@native.target`)
+    end
+
+    alias_native :old, :oldValue
+    alias_native :attribute, :attributeName
+  end
+
+  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
+
+  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
+
+  def take
+    `#@native.takeRecords()`.map { |r| Record.new(r) }
+  end
+
+  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/opal/browser/dom/node.rb

@@ -0,0 +1,317 @@
+module Browser; module DOM
+
+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
+
+  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
+
+  def ==(other)
+    `#@native === #{Native.try_convert(other)}`
+  end
+
+  def =~(name)
+    self.name.downcase == name.downcase
+  end
+
+  def <<(node)
+    add_child(node)
+  end
+
+  def <=>(other)
+    raise NotImplementedError
+  end
+
+  def add_child(node)
+    if native?(node)
+      `#@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)})`
+    end
+
+    self
+  end
+
+  def add_next_sibling(node)
+    `#@native.parentNode.insertBefore(node, #@native.nextSibling)`
+
+    self
+  end
+
+  def add_previous_sibling(node)
+    `#@native.parentNode.insertBefore(node, #@native)`
+
+    self
+  end
+
+  alias after add_next_sibling
+
+  def append_to(element)
+    element.add_child(self)
+
+    self
+  end
+
+  def ancestors(expression = nil)
+    return NodeSet.new(document) unless parent
+
+    parents = [parent]
+
+    while parent = parents.last.parent
+      parents << parent
+    end
+
+    if Document === parents.last
+      parents.pop
+    end
+
+    return NodeSet.new(document, parents) unless expression
+
+    NodeSet.new document, parents.select {|p|
+      p.matches?(expression)
+    }
+  end
+
+  alias before add_previous_sibling
+
+  def remove
+    detach
+    clear
+
+    self
+  end
+
+  def detach
+    parent.remove_child(self) if parent
+
+    self
+  end
+
+  def clear; end
+
+  def remove_child(element)
+    `#@native.removeChild(#{Native.try_convert(element)})`
+
+    self
+  end
+
+  def clear
+    children.each(&:remove)
+  end
+
+  def blank?
+    raise NotImplementedError
+  end
+
+  def cdata?
+    node_type == CDATA_SECTION_NODE
+  end
+
+  def child
+    children.first
+  end
+
+  def children
+    NodeSet.new(document, Native::Array.new(`#@native.childNodes`))
+  end
+
+  def children=(node)
+    raise NotImplementedError
+  end
+
+  def comment?
+    node_type == COMMENT_NODE
+  end
+
+  def document
+    DOM(`#@native.ownerDocument`)
+  end
+
+  def document?
+    node_type == DOCUMENT_NODE
+  end
+
+  def elem?
+    node_type == ELEMENT_NODE
+  end
+
+  alias element? elem?
+
+  def element_children
+    children.select(&:element?)
+  end
+
+  alias elements element_children
+
+  def first_element_child
+    element_children.first
+  end
+
+  def fragment?
+    node_type == DOCUMENT_FRAGMENT_NODE
+  end
+
+  def hash
+    # TODO: implement this properly
+  end
+
+  def inner_html(*)
+    `#@native.innerHTML`
+  end
+
+  def inner_html=(value)
+    `#@native.innerHTML = #{value}`
+  end
+
+  def inner_text(*)
+    `#@native.textContent`
+  end
+
+  alias content inner_text
+
+  def inner_text=(value)
+    `#@native.textContent = #{value}`
+  end
+
+  alias content= inner_text=
+
+  def last_element_child
+    element_children.last
+  end
+
+  def matches?(expression)
+    false
+  end
+
+  def name
+    `#@native.nodeName || nil`
+  end
+
+  def name=(value)
+    `#@native.nodeName = #{value.to_s}`
+  end
+
+  def namespace
+    `#@native.namespaceURI || nil`
+  end
+
+  def next
+    DOM(`#@native.nextSibling`) if `#@native.nextSibling != null`
+  end
+
+  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=
+
+  def node_type
+    `#@native.nodeType`
+  end
+
+  def parent
+    DOM(`#@native.parentNode`) if `#@native.parentNode != null`
+  end
+
+  def parent= (node)
+    `#@native.parentNode = #{Native.try_convert(node)}`
+  end
+
+  def parse (text, options = {})
+    raise NotImplementedError
+  end
+
+  def path
+    raise NotImplementedError
+  end
+
+  def previous
+    DOM(`#@native.previousSibling`) if `#@native.previousSibling != null`
+  end
+
+  alias previous= add_previous_sibling
+
+  def previous_element
+    current = self.previous
+
+    while current && !current.element?
+      current = current.previous
+    end
+
+    current
+  end
+
+  alias previous_sibling previous
+
+  # TODO: implement for NodeSet
+  def replace(node)
+    `#@native.parentNode.replaceChild(#@native, #{Native.try_convert(node)})`
+
+    node
+  end
+
+  alias text inner_text
+  alias text= inner_text=
+
+  def text?
+    node_type == TEXT_NODE
+  end
+
+  def traverse(&block)
+    raise NotImplementedError
+  end
+
+  alias type node_type
+
+  def value
+    `#@native.nodeValue || nil`
+  end
+
+  def value=(value)
+    `#@native.nodeValue = value`
+  end
+
+  def inspect
+    "#<DOM::Node: #{name}>"
+  end
+end
+
+end; end