opal-browser 0.2.0.beta1 → 0.3.2

data/opal/browser/database/sql.rb

@@ -0,0 +1,193 @@
+require 'ostruct'
+
+module Browser; module Database
+
+class SQL
+  # Check if the browser supports WebSQL.
+  def self.supported?
+    Browser.supports? 'WebSQL'
+  end
+
+  class Error < StandardError
+    def self.new(error)
+      return super if self != Error
+
+      [Unknown, Database, Version, TooLarge, Quota, Syntax, Constraint, Timeout] \
+        [`error.code`].new(`error.message`)
+    end
+
+    Unknown    = Class.new(self)
+    Database   = Class.new(self)
+    Version    = Class.new(self)
+    TooLarge   = Class.new(self)
+    Quota      = Class.new(self)
+    Syntax     = Class.new(self)
+    Constraint = Class.new(self)
+    Timeout    = Class.new(self)
+  end
+
+  include Native::Wrapper
+
+  # @return [String] the name of the database
+  attr_reader :name
+
+  # @return [String] the description for the database
+  attr_reader :description
+
+  # @return [Integer] the size constraint in bytes
+  attr_reader :size
+
+  # Open a database with the given name and options.
+  #
+  # @param name [String] the name for the database
+  # @param options [Hash] options to open the database
+  #
+  # @option options [String] :description the description for the database
+  # @option options [String] :version ('') the expected version of the database
+  # @option options [Integer] :size (5 * 1024 * 1024) the size constraint in bytes
+  def initialize(name, options = {})
+    @name        = name
+    @description = options[:description] || name
+    @version     = options[:version]     || ''
+    @size        = options[:size]        || 2 * 1024 * 1024
+
+    super(`window.openDatabase(#{name}, #{@version}, #{@description}, #{@size})`)
+  end
+
+  # @overload version()
+  #
+  #   Get the version of the database.
+  #
+  #   @return [String]
+  #
+  # @overload version(from, to, &block)
+  #
+  #   Migrate the database to a new version.
+  #
+  #   @param from [String] the version you're migrating from
+  #   @param to [String] the version you're migrating to
+  #
+  #   @yieldparam transaction [Transaction] the transaction to work with
+  def version(from = nil, to = nil, &block)
+    return `#@native.version` unless block
+
+    `#@native.changeVersion(#{from}, #{to},
+      #{->(t) { block.call(Transaction.new(self, t)) }})`
+  end
+
+  # Start a transaction on the database.
+  #
+  # @yieldparam transaction [Transaction] the transaction to work on
+  def transaction(&block)
+    raise ArgumentError, 'no block given' unless block
+
+    `#@native.transaction(#{->(t) { block.call(Transaction.new(self, t)) }})`
+  end
+
+  # Allows you to make changes to the database or read data from it.
+  class Transaction
+    include Native::Wrapper
+
+    # @return [Database] the database the transaction has been created from
+    attr_reader :database
+
+    # @private
+    def initialize(database, transaction)
+      @database = database
+
+      super(transaction)
+    end
+
+    # Query the database.
+    #
+    # @param query [String] the SQL query to send
+    # @param parameters [Array] optional bind parameters for the query
+    #
+    # @return [Promise]
+    def query(query, *parameters)
+      promise = Promise.new
+
+      `#@native.executeSql(#{query}, #{parameters},
+        #{->(_, r) { promise.resolve(Result.new(self, r)) }},
+        #{->(_, e) { promise.reject(Error.new(e)) }})`
+
+      promise
+    end
+  end
+
+  # Represents a row.
+  class Row < OpenStruct
+    # @private
+    def initialize(row)
+      super(Hash.new(row))
+    end
+
+    def inspect
+      "#<SQL::Row: #{Hash.new(@native).inspect}>"
+    end
+  end
+
+  class Result
+    include Native::Wrapper
+
+    # @return [Transaction] the transaction the result came from
+    attr_reader :transaction
+
+    # @return [SQL] the database the result came from
+    attr_reader :database
+
+    # @private
+    def initialize(transaction, result)
+      @transaction = transaction
+      @database    = transaction.database
+
+      super(result)
+    end
+
+    include Enumerable
+
+    # Get a row from the result.
+    #
+    # @param index [Integer] the index for the row
+    #
+    # @return [Row]
+    def [](index)
+      if index < 0
+        index += length
+      end
+
+      unless index < 0 || index >= length
+        Row.new(`#@native.rows.item(index)`)
+      end
+    end
+
+    # Enumerate over the rows.
+    #
+    # @yieldparam row [Row]
+    #
+    # @return [self]
+    def each(&block)
+      return enum_for :each unless block
+
+      %x{
+        for (var i = 0, length = #@native.rows.length; i < length; i++) {
+          #{block.call(self[`i`])};
+        }
+      }
+
+      self
+    end
+
+    # @!attribute [r] length
+    # @return [Integer] number of rows in the result
+    def length
+      `#@native.rows.length`
+    end
+
+    # @!attribute [r] affected
+    # @return [Integer] number of affected rows
+    alias_native :affected, :rowsAffected
+  end
+end
+
+end; end

data/opal/browser/delay.rb

@@ -17,8 +17,6 @@ class Delay
     @window = Native.convert(window)
     @after  = time
     @block  = block
-
-    start
   end
 
   # Abort the timeout.
@@ -39,10 +37,48 @@ class Window
   #
   # @return [Delay] the object representing the timeout
   def after(time, &block)
+    Delay.new(@native, time, &block).tap(&:start)
+  end
+
+  # Execute a block after the given seconds, you have to call [#start] on it
+  # yourself.
+  #
+  # @param time [Float] the seconds after it gets called
+  #
+  # @return [Delay] the object representing the timeout
+  def after!(time, &block)
     Delay.new(@native, time, &block)
   end
+
+  # Returns a promise that will resolve after the given seconds.
+  #
+  # @param time [Float] the seconds after it gets called
+  #
+  # @return [Promise] the promise that will resolve after timeout happens
+  def resolve_after(time)
+    promise = Promise.new
+    Delay.new(@native, time) { promise.resolve }.start
+    promise
+  end
+end
+
 end
 
+module Kernel
+  # (see Browser::Window#after)
+  def after(time, &block)
+    $window.after(time, &block)
+  end
+
+  # (see Browser::Window#after!)
+  def after!(time, &block)
+    $window.after!(time, &block)
+  end
+
+  # (see Browser::Window#resolve_after)
+  def resolve_after(time)
+    $window.resolve_after(time)
+  end
 end
 
 class Proc
@@ -50,11 +86,9 @@ class Proc
   def after(time)
     $window.after(time, &self)
   end
-end
 
-module Kernel
-  # (see Browser::Window#after)
-  def after(time, &block)
-    $window.after(time, &block)
+  # (see Browser::Window#after!)
+  def after!(time)
+    $window.after!(time, &self)
   end
 end

data/opal/browser/dom/attribute.rb

@@ -2,23 +2,24 @@ module Browser; module DOM
 
 # Encapsulates an {Element} attribute.
 class Attribute
-  include Native
-
-  # Returns true if the attribute is an id.
-  def id?
-    `#@native.isId`
-  end
+  include Browser::NativeCachedWrapper
 
   # @!attribute [r] name
   # @return [String] the name of the attribute
-  def name
-    `#@native.name`
-  end
+  alias_native :name
 
-  # @!attribute [r] value
+  # @!attribute value
   # @return [String] the value of the attribute
-  def value
-    `#@native.value`
+  alias_native :value
+  alias_native :value=
+
+  # Returns true if the attribute is an id.
+  if Browser.supports? 'Attr.isId'
+    alias_native :id?, :isId
+  else
+    def id?
+      name == :id
+    end
   end
 end
 

data/opal/browser/dom/builder.rb

@@ -29,23 +29,40 @@ class Builder
   def self.build(builder, item)
     to_h.each {|klass, block|
       if klass === item
-        break block.call(builder, item)
+        return block.call(builder, item)
       end
     }
+
+    raise ArgumentError, "cannot build unknown item #{item}"
   end
 
   attr_reader :document, :element
 
-  def initialize(document, element = nil, &block)
+  NEW_PAGGIO = (Paggio::HTML.instance_method(:build!) rescue false)
+
+  def initialize(document, builder=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
-      }
+
+    # Compatibility issue due to an unreleased Paggio gem.
+    # Let's try to support both versions. When Paggio is released,
+    # we may remove it.
+
+    if NEW_PAGGIO
+      @builder = Paggio::HTML.new(defer: true, &block)
+
+      build = proc do
+        @builder.build!(force_call: !!builder)
+        @roots = @builder.each.map { |e| Builder.build(self, e) }
+      end
+
+      if builder
+        builder.extend!(@builder, &build)
+      else
+        build.()
+      end
+    else
+      @builder = Paggio::HTML.new(&block)
+      @roots = @builder.each.map { |e| Builder.build(self, e) }
     end
   end
 
@@ -59,15 +76,12 @@ Builder.for String do |b, item|
 end
 
 Builder.for Paggio::HTML::Element do |b, item|
-  dom = b.document.create_element(`item.name`)
+  options = {}
 
-  if Hash === `item.attributes`
-    dom.attributes.merge!(`item.attributes`)
-  end
+  options[:attrs] = `item.attributes` if Hash === `item.attributes`
+  options[:classes] = `item.class_names`
 
-  `item.class_names`.each {|value|
-    dom.add_class value
-  }
+  dom = b.document.create_element(`item.name`, **options)
 
   if on = `item.on || nil`
     on.each {|args, block|

data/opal/browser/dom/document.rb

@@ -1,34 +1,13 @@
-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
-
-  if Browser.supports? 'Document.view'
-    def window
-      Window.new(`#@native.defaultView`)
-    end
-  elsif Browser.supports? 'Document.window'
-    def window
-      Window.new(`#@native.parentWindow`)
-    end
-  else
-    def window
-      raise NotImplementedError, 'window from document unsupported'
-    end
-  end
-
-  def create_text(content)
-    DOM(`#@native.createTextNode(#{content})`)
-  end
+  include DocumentOrShadowRoot
 
+  # Get the first element matching the given ID, CSS selector or XPath.
+  #
+  # @param what [String] ID, CSS selector or XPath
+  #
+  # @return [Element?] the first matching element
   def [](what)
     %x{
       var result = #@native.getElementById(what);
@@ -43,42 +22,195 @@ class Document < Element
 
   alias at []
 
+  # @!attribute [r] body
+  # @return [Element?] the body element of the document
+  def body
+    DOM(`#@native.body`)
+  rescue ArgumentError
+    raise '$document.body is not defined; try to wrap your code in $document.ready{}'
+  end
+
+  # Create a new element for the document.
+  #
+  # @param name [String] the node name
+  # @param builder [Browser::DOM::Builder] optional builder to append element to
+  # @param options [String] :namespace optional namespace name
+  # @param options [String] :is optional WebComponents is parameter
+  # @param options [String] :id optional id to set
+  # @param options [Array<String>] :classes optional classes to set
+  # @param options [Hash] :attrs optional attributes to set
+  #
+  # @return [Element]
+  def create_element(name, builder=nil, **options, &block)
+    opts = {}
+
+    if options[:is] ||= (options.dig(:attrs, :is))
+      opts[:is] = options[:is]
+    end
+
+    if ns = options[:namespace]
+      elem = `#@native.createElementNS(#{ns}, #{name}, #{opts.to_n})`
+    else
+      elem = `#@native.createElement(name, #{opts.to_n})`
+    end
+
+    if options[:classes]
+      `#{elem}.className = #{Array(options[:classes]).join(" ")}`
+    end
+
+    if options[:id]
+      `#{elem}.id = #{options[:id]}`
+    end
+
+    if options[:attrs]
+      options[:attrs].each do |k,v|
+        next unless v
+        `#{elem}.setAttribute(#{k}, #{v})`
+      end
+    end
+
+    dom = DOM(elem)
+
+    if block_given?
+      dom.inner_dom(builder, &block)
+    end
+
+    if builder
+      builder << dom
+    end
+
+    dom
+  end
+
+  # Create a new document fragment.
+  #
+  # @return [DocumentFragment]
+  def create_document_fragment
+    DOM(`#@native.createDocumentFragment()`)
+  end
+
+  # Create a new text node for the document.
+  #
+  # @param content [String] the text content
+  #
+  # @return [Text]
+  def create_text(content)
+    DOM(`#@native.createTextNode(#{content})`)
+  end
+
+  # Create a new comment node for the document.
+  #
+  # @param content [String] the comment content
+  #
+  # @return [Comment]
+  def create_comment(content)
+    DOM(`#@native.createComment(#{content})`)
+  end
+
   def document
     self
   end
 
+  # @!attribute [r] head
+  # @return [Element?] the head element of the document
+  def head
+    DOM(`#@native.getElementsByTagName("head")[0]`)
+  end
+
   def inspect
-    "#<DOM::Document: #{children.inspect}>"
+    "#<DOM::Document>"
   end
 
-  def title
-    `#@native.title`
+  if Browser.supports? 'Event.addListener'
+    def ready(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      return block.call if ready?
+
+      on 'dom:load' do |e|
+        e.off
+
+        block.call
+      end
+    end
+  elsif Browser.supports? 'Event.attach'
+    def ready(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      return block.call if ready?
+
+      on 'ready:state:change' do |e|
+        if ready?
+          e.off
+
+          block.call
+        end
+      end
+    end
+  else
+    # Wait for the document to be ready and call the block.
+    def ready(&block)
+      raise NotImplementedError, 'document ready unsupported'
+    end
   end
 
-  def title=(value)
-    `#@native.title = value`
+  # Check if the document is ready.
+  def ready?
+    `#@native.readyState === "complete" || #@native.readyState === "interactive"`
   end
 
+  # @!attribute referrer
+  # @return [String] the referring document, or empty string if direct access
+  def referrer
+    `#@native.referrer`
+  end
+
+  # @!attribute root
+  # @return [Element?] the root element of the document
   def root
     DOM(`#@native.documentElement`)
   end
 
-  def head
-    DOM(`#@native.getElementsByTagName("head")[0]`)
+  def root=(element)
+    `#@native.documentElement = #{Native.convert(element)}`
   end
 
-  def body
-    DOM(`#@native.body`)
+  # @!attribute title
+  # @return [String] the document title
+  def title
+    `#@native.title`
   end
 
-  def style_sheets
-    Native::Array.new(`#@native.styleSheets`) {|e|
-      CSS::StyleSheet.new(e)
-    }
+  def title=(value)
+    `#@native.title = value`
   end
 
-  def root=(element)
-    `#@native.documentElement = #{Native.convert(element)}`
+  # @!attribute [r] hidden?
+  # @return [Boolean] is the page considered hidden?
+  def hidden?
+    `#@native.hidden`
+  end
+
+  # @!attribute [r] visibility
+  # @return [String] the visibility state of the document - prerender, hidden or visible
+  def visibility
+    `#@native.visibilityState`
+  end
+
+  if Browser.supports? 'Document.view'
+    def window
+      Window.new(`#@native.defaultView`)
+    end
+  elsif Browser.supports? 'Document.window'
+    def window
+      Window.new(`#@native.parentWindow`)
+    end
+  else
+    # @!attribute [r] window
+    # @return [Window] the window for the document
+    def window
+      raise NotImplementedError, 'window from document unsupported'
+    end
   end
 end
 

data/opal/browser/dom/document_fragment.rb

@@ -1,7 +1,25 @@
 module Browser; module DOM
 
+# TODO: DocumentFragment is not a subclass of Element, but
+#       a subclass of Node. It implements a ParentNode.
+#
+# @see https://github.com/opal/opal-browser/pull/46
 class DocumentFragment < Element
+  def self.new(node)
+    if self == DocumentFragment
+      if defined? `#{node}.mode`
+        ShadowRoot.new(node)
+      else
+        super
+      end
+    else
+      super
+    end
+  end
 
+  def self.create
+    $document.create_document_fragment
+  end
 end
 
 end; end

data/opal/browser/dom/document_or_shadow_root.rb

@@ -0,0 +1,19 @@
+module Browser; module DOM
+
+# Document and ShadowRoot have some methods and properties in common.
+# This solution mimics how it's done in DOM.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/DocumentOrShadowRoot
+module DocumentOrShadowRoot
+  # @!attribute [r] style_sheets
+  # @return [Array<CSS::StyleSheet>] the style sheets for the document
+  def style_sheets
+    Native::Array.new(`#@native.styleSheets`) {|e|
+      CSS::StyleSheet.new(e)
+    }
+  end
+
+  alias stylesheets style_sheets
+end
+
+end; end