opal-browser 0.1.0.beta1

data/opal/browser/dom.rb

@@ -0,0 +1,95 @@
+require 'browser/dom/event'
+require 'browser/dom/node_set'
+require 'browser/dom/node'
+require 'browser/dom/attribute'
+require 'browser/dom/character_data'
+require 'browser/dom/text'
+require 'browser/dom/cdata'
+require 'browser/dom/comment'
+require 'browser/dom/element'
+require 'browser/dom/document'
+require 'browser/dom/document_fragment'
+require 'browser/dom/builder'
+require 'browser/dom/mutation_observer'
+
+require 'browser/dom/compatibility'
+
+module Kernel
+  # Parse an XML string into a DOM usable {Browser::DOM::Document}
+  #
+  # @param what [String] the string to parse
+  # @return [Browser::DOM::Document] the document
+  def XML(what)
+    %x{
+      var doc;
+
+      if (window.DOMParser) {
+        doc = new DOMParser().parseFromString(what, 'text/xml');
+      }
+      else {
+        doc       = new ActiveXObject('Microsoft.XMLDOM');
+        doc.async = 'false';
+        doc.loadXML(what);
+      }
+    }
+
+    DOM(`doc`)
+  end
+
+  # Wrap a native element or create a DOM tree using the {Paggio::HTML} DSL.
+  #
+  # @return [Browser::DOM::Node]
+  def DOM(*args, &block)
+    if block
+      document = args.shift || $document
+      element  = args.shift
+
+      roots = Browser::DOM::Builder.new(document, element, &block).to_a
+
+      if roots.length == 1
+        roots.first
+      else
+        Browser::DOM::NodeSet.new(document, roots)
+      end
+    else
+      what     = args.shift
+      document = args.shift || $document
+
+      if native?(what)
+        Browser::DOM::Node.new(what)
+      elsif Browser::DOM::Node === what
+        what
+      elsif String === what
+        %x{
+          var doc = #{Native.try_convert(document)}.createElement('div');
+          doc.innerHTML = what;
+
+          return #{DOM(`doc.childNodes.length == 1 ? doc.childNodes[0] : doc`)};
+        }
+      else
+        raise ArgumentError, "argument not DOM convertible"
+      end
+    end
+  end
+end
+
+module Browser
+
+class Window
+  include DOM::Event::Target
+
+  target {|value|
+    $window if `#{value} == window`
+  }
+
+  # Get the {DOM::Document} for this window.
+  #
+  # @return [DOM::Document]
+  def document
+    DOM(`#@native.document`)
+  end
+end
+
+end
+
+$document = $window.document

data/opal/browser/dom/attribute.rb

@@ -0,0 +1,19 @@
+module Browser; module DOM
+
+class Attribute
+  include Native
+
+  def id?
+    `#@native.isId`
+  end
+
+  def name
+    `#@native.name`
+  end
+
+  def value
+    `#@native.value`
+  end
+end
+
+end; end

data/opal/browser/dom/builder.rb

@@ -0,0 +1,97 @@
+# Temporary fix for a bug in String#scan
+module Paggio::Utils
+  def self.heredoc(string)
+    string
+  end
+end
+
+class Paggio::HTML::Element < BasicObject
+  def on(*args, &block)
+    (@on ||= []) << [args, block]
+  end
+
+  def style(*args, &block)
+    @style = [args, block]
+  end
+end
+
+module Browser; module DOM
+
+class Builder
+  def self.to_h
+    @builders ||= {}
+  end
+
+  def self.for(klass, &block)
+    if block
+      to_h[klass] = block
+    else
+      to_h[klass]
+    end
+  end
+
+  def self.build(builder, item)
+    to_h.each {|klass, block|
+      if klass === item
+        break block.call(builder, item)
+      end
+    }
+  end
+
+  attr_reader :document, :element
+
+  def initialize(document, element = nil, &block)
+    @document = document
+    @element  = element
+    @builder  = Paggio::HTML.new(&block)
+    @roots    = @builder.each.map { |e| Builder.build(self, e) }
+
+    if @element
+      @roots.each {|root|
+        @element << root
+      }
+    end
+  end
+
+  def to_a
+    @roots
+  end
+end
+
+Builder.for String do |b, item|
+  b.document.create_text(item)
+end
+
+Builder.for Paggio::HTML::Element do |b, item|
+  dom = b.document.create_element(`item.name`)
+
+  if Hash === `item.attributes`
+    dom.attributes.merge!(`item.attributes`)
+  end
+
+  `item.class_names`.each {|value|
+    dom.add_class value
+  }
+
+  if on = `item.on || nil`
+    on.each {|args, block|
+      dom.on(*args, &block)
+    }
+  end
+
+  if style = `item.style || nil`
+    dom.style(*style[0], &style[1])
+  end
+
+  if inner = `item.inner_html || nil`
+    dom.inner_html = inner
+  else
+    item.each {|child|
+      dom << Builder.build(b, child)
+    }
+  end
+
+  dom
+end
+
+end; end

data/opal/browser/dom/cdata.rb

@@ -0,0 +1,9 @@
+module Browser; module DOM
+
+class CDATA < Text
+  def inspect
+    "#<DOM::CDATA: #{value}>"
+  end
+end
+
+end; end

data/opal/browser/dom/character_data.rb

@@ -0,0 +1,37 @@
+module Browser; module DOM
+
+class CharacterData < Node
+  def data
+    `#@native.data`
+  end
+
+  def append(string)
+    `#@native.appendData(string)`
+
+    self
+  end
+
+  def insert(string, offset = 0)
+    `#@native.insertData(offset, string)`
+
+    self
+  end
+
+  def delete(count, offset = 0)
+    `#@native.deleteData(offset, count)`
+
+    self
+  end
+
+  def replace(string, offset = 0, count = `#@native.length`)
+    `#@native.replaceData(offset, count, string)`
+
+    self
+  end
+
+  def substring(count, offset = 0)
+    `#@native.substringData(offset, count)`
+  end
+end
+
+end; end

data/opal/browser/dom/comment.rb

@@ -0,0 +1,9 @@
+module Browser; module DOM
+
+class Comment < CharacterData
+  def inspect
+    "#<DOM::Comment: #{value}>"
+  end
+end
+
+end; end

data/opal/browser/dom/compatibility.rb

@@ -0,0 +1,8 @@
+require 'browser/compatibility/dom/document/window'
+
+require 'browser/compatibility/dom/mutation_observer'
+
+require 'browser/compatibility/dom/element/matches'
+require 'browser/compatibility/dom/element/css'
+require 'browser/compatibility/dom/element/offset'
+require 'browser/compatibility/dom/element/style'

data/opal/browser/dom/document.rb

@@ -0,0 +1,83 @@
+require 'browser/location'
+
+module Browser; module DOM
+
+class Document < Element
+  def create_element(name, options = {})
+    if ns = options[:namespace]
+      DOM(`#@native.createElementNS(#{ns}, #{name})`)
+    else
+      DOM(`#@native.createElement(name)`)
+    end
+  end
+
+  def window
+    Window.new(`#@native.defaultView`)
+  end
+
+  def create_text(content)
+    DOM(`#@native.createTextNode(#{content})`)
+  end
+
+  def [](what)
+    %x{
+      var result = #@native.getElementById(what);
+
+      if (result) {
+        return #{DOM(`result`)};
+      }
+    }
+
+    xpath(what).first || css(what).first
+  end
+
+  alias at []
+
+  def cookies
+    Cookies.new(@native) if defined?(`#@native.cookie`)
+  end
+
+  def document
+    self
+  end
+
+  def inspect
+    "#<DOM::Document: #{children.inspect}>"
+  end
+
+  def location
+    Location.new(`#@native.location`) if `#@native.location`
+  end
+
+  def title
+    `#@native.title`
+  end
+
+  def title=(value)
+    `#@native.title = value`
+  end
+
+  def root
+    DOM(`#@native.documentElement`)
+  end
+
+  def head
+    DOM(`#@native.getElementsByTagName("head")[0]`)
+  end
+
+  def body
+    DOM(`#@native.body`)
+  end
+
+  def style_sheets
+    Native::Array.new(`#@native.styleSheets`) {|e|
+      CSS::StyleSheet.new(e)
+    }
+  end
+
+  def root=(element)
+    `#@native.documentElement = #{Native.convert(element)}`
+  end
+end
+
+end; end

data/opal/browser/dom/document_fragment.rb

@@ -0,0 +1,7 @@
+module Browser; module DOM
+
+class DocumentFragment < Element
+
+end
+
+end; end

data/opal/browser/dom/element.rb

@@ -0,0 +1,290 @@
+require 'browser/dom/element/position'
+require 'browser/dom/element/offset'
+require 'browser/dom/element/scroll'
+
+require 'browser/dom/element/input'
+
+module Browser; module DOM
+
+class Element < Node
+  def self.create(*args)
+    $document.create_element(*args)
+  end
+
+  def self.new(node)
+    if self == Element
+      case `node.nodeName`.downcase
+      when :input
+        Input.new(node)
+
+      else super
+      end
+    else
+      super
+    end
+  end
+
+  include Event::Target
+
+  target {|value|
+    DOM(value) rescue nil
+  }
+
+  alias_native :id
+
+  def add_class(*names)
+    `#@native.className = #{(class_names + names).uniq.join ' '}`
+
+    self
+  end
+
+  def remove_class(*names)
+    `#@native.className = #{(class_names - names).join ' '}`
+
+    self
+  end
+
+  alias_native :class_name, :className
+
+  def class_names
+    `#@native.className`.split(/\s+/).reject(&:empty?)
+  end
+
+  alias attribute attr
+
+  def attribute_nodes
+    Native::Array.new(`#@native.attributes`, get: :item) { |e| DOM(e) }
+  end
+
+  def attributes(options = {})
+    Attributes.new(self, options)
+  end
+
+  def get(name, options = {})
+    if namespace = options[:namespace]
+      `#@native.getAttributeNS(#{namespace.to_s}, #{name.to_s}) || nil`
+    else
+      `#@native.getAttribute(#{name.to_s}) || nil`
+    end
+  end
+
+  def set(name, value, options = {})
+    if namespace = options[:namespace]
+      `#@native.setAttributeNS(#{namespace.to_s}, #{name.to_s}, #{value})`
+    else
+      `#@native.setAttribute(#{name.to_s}, #{value.to_s})`
+    end
+  end
+
+  alias [] get
+  alias []= set
+
+  alias attr get
+  alias attribute get
+
+  alias get_attribute get
+  alias set_attribute set
+
+  def key?(name)
+    !!self[name]
+  end
+
+  def keys
+    attributes_nodesmap(&:name)
+  end
+
+  def values
+    attribute_nodes.map(&:value)
+  end
+
+  def remove_attribute(name)
+    `#@native.removeAttribute(name)`
+  end
+
+  def size(*inc)
+    Size.new(`#@native.offsetWidth`, `#@native.offsetHeight`)
+  end
+
+  def position
+    Position.new(self)
+  end
+
+  def offset(*values)
+    off = Offset.new(self)
+
+    unless values.empty?
+      off.set(*values)
+    end
+
+    off
+  end
+
+  def offset=(value)
+    offset.set(*value)
+  end
+
+  def scroll
+    Scroll.new(self)
+  end
+
+  def inner_dom(&block)
+    # FIXME: when block passing is fixed
+    doc = document
+    clear; Builder.new(doc, self, &block)
+
+    self
+  end
+
+  def inner_dom=(node)
+    clear; self << node
+  end
+
+  def /(*paths)
+    paths.map { |path| xpath(path) }.flatten.uniq
+  end
+
+  def at(path)
+    xpath(path).first || css(path).first
+  end
+
+  def at_css(*rules)
+    rules.each {|rule|
+      found = css(rule).first
+
+      return found if found
+    }
+
+    nil
+  end
+
+  def at_xpath(*paths)
+    paths.each {|path|
+      found = xpath(path).first
+
+      return found if found
+    }
+
+    nil
+  end
+
+  def search(*selectors)
+    NodeSet.new document, selectors.map {|selector|
+      xpath(selector).to_a.concat(css(selector).to_a)
+    }.flatten.uniq
+  end
+
+  def css(path)
+    NodeSet.new(document, Native::Array.new(`#@native.querySelectorAll(path)`))
+  end
+
+  def xpath(path)
+    result = []
+
+    begin
+      %x{
+        var tmp = (#@native.ownerDocument || #@native).evaluate(
+          path, #@native, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+
+        result = #{Native::Array.new(`tmp`, get: :snapshotItem, length: :snapshotLength)};
+      }
+    rescue; end
+
+    NodeSet.new(document, result)
+  end
+
+  def style(data = nil, &block)
+    style = CSS::Declaration.new(`#@native.style`)
+
+    return style unless data || block
+
+    if data.is_a?(String)
+      style.replace(data)
+    elsif data.is_a?(Enumerable)
+      style.assign(data)
+    end
+
+    if block
+      style.apply(&block)
+    end
+
+    self
+  end
+
+  def style!
+    CSS::Declaration.new(`#{window.to_n}.getComputedStyle(#@native, null)`)
+  end
+
+  def data(what)
+    unless defined?(`#@native.$data`)
+      `#@native.$data = {}`
+    end
+
+    if Hash === what
+      what.each {|name, value|
+        `#@native.$data[name] = value`
+      }
+    else
+      %x{
+        var value = #@native.$data[what];
+
+        if (value === undefined) {
+          return nil;
+        }
+        else {
+          return value;
+        }
+      }
+    end
+  end
+
+  def matches?(selector)
+    `#@native.matches(#{selector})`
+  end
+
+  def window
+    document.window
+  end
+
+  def inspect
+    "#<DOM::Element: #{name}>"
+  end
+
+  class Attributes
+    include Enumerable
+
+    attr_reader :namespace
+
+    def initialize(element, options)
+      @element   = element
+      @namespace = options[:namespace]
+    end
+
+    def each(&block)
+      return enum_for :each unless block_given?
+
+      @element.attribute_nodes.each {|attr|
+        yield attr.name, attr.value
+      }
+
+      self
+    end
+
+    def [](name)
+      @element.get_attribute(name, namespace: @namespace)
+    end
+
+    def []=(name, value)
+      @element.set_attribute(name, value, namespace: @namespace)
+    end
+
+    def merge!(hash)
+      hash.each {|name, value|
+        self[name] = value
+      }
+
+      self
+    end
+  end
+end
+
+end; end