opal-browser 0.1.0.beta1 → 0.3.1

data/opal/browser/crypto.rb

@@ -0,0 +1,79 @@
+module Browser
+
+# Implements (parts of) the web crypto interface
+#
+# https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API
+class Crypto
+  include NativeCachedWrapper
+
+  class Digest
+    def initialize(buf)
+      @buffer = Buffer.new(buf)
+    end
+
+    attr_reader :buffer
+
+    # Convert a digest to a hexadecimal string
+    def to_hex
+      buffer.to_a.map { |i| "%02x" % i }.join
+    end
+
+    # Convert a digest to a binary string
+    def to_s
+      buffer.to_a.map { |i| "%c" % i }.join
+    end
+
+    # Convert a digest to a Base64-encoded string
+    #
+    # You will need to `require "base64"`
+    def to_b64
+      Base64.strict_encode64(to_s)
+    end
+
+    # Convert a digest to a urlsafe Base64-encoded string
+    #
+    # You will need to `require "base64"`
+    def to_u64(padding: false)
+      Base64.urlsafe_encode64(to_s, padding: padding)
+    end
+  end
+
+  # Compute a cryptographic digest of data (a Buffer). If block is given,
+  # it will call a block, otherwise it will return a Promise that will
+  # return once a digest is computed.
+  #
+  # Allowed values for algo: SHA-1, SHA-256 (default), SHA-368, SHA-512.
+  #
+  # The block/promise will be given an argument of type {Digest} which can
+  # be used to format a digest.
+  #
+  # Example:
+  # ```
+  # Browser::Blob.new(['test']).buffer.then { |b|
+  #   $window.crypto.digest(b)
+  # }.then { |d|
+  #   puts d.to_hex
+  # }
+  # ```
+  def digest data, algo = 'SHA-256', &block
+    promise = nil
+    unless block_given?
+      promise = Promise.new
+      block = proc { |i| promise.resolve(i) }
+    end
+    resblock = proc { |i| block.call(Digest.new(i)) }
+
+    `#@native.subtle.digest(algo, #{Native.convert(data)}).then(#{resblock.to_n})`
+    promise
+  end
+end
+
+class Window
+  # @!attribute [r] crypto
+  # @return [Crypto] the crypto interface of this window
+  def crypto
+    @crypto ||= Crypto.new(`#@native.crypto`)
+  end
+end
+
+end

data/opal/browser/css/declaration.rb

@@ -1,7 +1,7 @@
 module Browser; module CSS
 
 class Declaration
-  include Native
+  include Browser::NativeCachedWrapper
   include Enumerable
 
   def rule
@@ -18,21 +18,16 @@ class Declaration
 
   def replace(string)
     `#@native.cssText = #{string}`
-
-    self
   end
 
   def apply(&block)
     Paggio::CSS::Definition.new(&block).each {|style|
-      # FIXME: use ternary operator when it's fixed
       if style.important
         `#@native.setProperty(#{style.name}, #{style.value}, "important")`
       else
         `#@native.setProperty(#{style.name}, #{style.value}, "")`
       end
     }
-
-    self
   end
 
   def delete(name)

data/opal/browser/css/rule.rb

@@ -1,7 +1,7 @@
 module Browser; module CSS
 
 class Rule
-  include Native
+  include Browser::NativeCachedWrapper
 
   STYLE_RULE               = 1
   CHARSET_RULE             = 2

data/opal/browser/css/style_sheet.rb

@@ -1,10 +1,10 @@
 module Browser; module CSS
 
 class StyleSheet
-  include Native
+  include Browser::NativeCachedWrapper
 
   def initialize(what)
-    if what.is_a? DOM::Element
+    if DOM::Element === what
       super(`#{what.to_n}.sheet`)
     else
       super(what)

data/opal/browser/css.rb

@@ -4,19 +4,35 @@ require 'browser/css/rule'
 require 'browser/css/rule/style'
 
 module Kernel
-  # Create a <style> element from a string or a block using the
-  # {Browser::CSS::Builder} DSL.
+  # @overload CSS(document = $document, &block)
   #
-  # @param text [String] the CSS text
-  # @return [Browser::DOM::Element] the create <style> element
-  def CSS(text = nil, &block)
-    style = $document.create_element(:style)
+  #   Create a `<style>` element from a {Paggio::CSS} DSL.
+  #
+  #   @param document [Browser::DOM::Document] the document instance
+  #     we intend to use
+  #
+  #   @return [Browser::DOM::Element] the created `<style>` element
+  #
+  # @overload CSS(string, document = $document)
+  #
+  #   Create a `<style>` element from a string.
+  #
+  #   @param document [Browser::DOM::Document] the document instance
+  #     we intend to use
+  #
+  #   @return [Browser::DOM::Element] the created `<style>` element
+  def CSS(*args, &block)
+    document = if args.length > 1 || block_given?
+      args.pop
+    end || $document
+
+    style = document.create_element(:style)
     style[:type] = 'text/css'
 
     if block
       style.inner_text = Paggio.css(&block)
     else
-      style.inner_text = text
+      style.inner_text = args.join("")
     end
 
     style

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

@@ -0,0 +1,94 @@
+module Browser
+
+# Allows you to delay the call to a function which gets called after the
+# given time.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/Window.setTimeout
+class Delay
+  # @!attribute [r] after
+  # @return [Float] the seconds after which the block is called
+  attr_reader :after
+
+  # Create and start a timeout.
+  #
+  # @param window [Window] the window to start the timeout on
+  # @param time [Float] seconds after which the block is called
+  def initialize(window, time, &block)
+    @window = Native.convert(window)
+    @after  = time
+    @block  = block
+  end
+
+  # Abort the timeout.
+  def abort
+    `#@window.clearTimeout(#@id)`
+  end
+
+  # Start the delay.
+  def start
+    @id = `#@window.setTimeout(#{@block.to_n}, #@after * 1000)`
+  end
+end
+
+class Window
+  # Execute a block after the given seconds.
+  #
+  # @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).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
+  # (see Browser::Window#after)
+  def after(time)
+    $window.after(time, &self)
+  end
+
+  # (see Browser::Window#after!)
+  def after!(time)
+    $window.after!(time, &self)
+  end
+end

data/opal/browser/dom/attribute.rb

@@ -1,18 +1,25 @@
 module Browser; module DOM
 
+# Encapsulates an {Element} attribute.
 class Attribute
-  include Native
+  include Browser::NativeCachedWrapper
 
-  def id?
-    `#@native.isId`
-  end
+  # @!attribute [r] name
+  # @return [String] the name of the attribute
+  alias_native :name
 
-  def name
-    `#@native.name`
-  end
+  # @!attribute value
+  # @return [String] the value of the attribute
+  alias_native :value
+  alias_native :value=
 
-  def value
-    `#@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

@@ -9,10 +9,6 @@ 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
@@ -33,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
 
@@ -63,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|
@@ -79,10 +89,6 @@ Builder.for Paggio::HTML::Element do |b, item|
     }
   end
 
-  if style = `item.style || nil`
-    dom.style(*style[0], &style[1])
-  end
-
   if inner = `item.inner_html || nil`
     dom.inner_html = inner
   else
@@ -94,4 +100,8 @@ Builder.for Paggio::HTML::Element do |b, item|
   dom
 end
 
+Builder.for DOM::Node do |b, item|
+  item
+end
+
 end; end

data/opal/browser/dom/character_data.rb

@@ -1,34 +1,70 @@
 module Browser; module DOM
 
 class CharacterData < Node
+  # Append data to the node.
+  #
+  # @param string [String] the data to add
+  #
+  # @return [self]
+  def append(string)
+    `#@native.appendData(string)`
+
+    self
+  end
+
+  # @!attribute [r] data
+  # @return [String] the data of the node
   def data
     `#@native.data`
   end
 
-  def append(string)
-    `#@native.appendData(string)`
+  # Delete data from the node.
+  #
+  # @param count [Integer] how much data to delete
+  # @param offset [Integer] the offset to start at
+  #
+  # @return [self]
+  def delete(count, offset = 0)
+    `#@native.deleteData(offset, count)`
 
     self
   end
 
+  # Insert data in the node.
+  #
+  # @param string [String] the data to insert
+  # @param offset [Integer] the offset to start at
+  #
+  # @return [self]
   def insert(string, offset = 0)
     `#@native.insertData(offset, string)`
 
     self
   end
 
-  def delete(count, offset = 0)
-    `#@native.deleteData(offset, count)`
-
-    self
-  end
+  # @!attribute [r] length
+  # @return [Integer] the length of the node
+  alias_native :length
 
+  # Replace data in the node.
+  #
+  # @param string [String] the data to replace with
+  # @param offset [Integer] the offset to start at
+  # @param count [Integer] how much data to replace
+  #
+  # @return [self]
   def replace(string, offset = 0, count = `#@native.length`)
     `#@native.replaceData(offset, count, string)`
 
     self
   end
 
+  # Get a substring of the data.
+  #
+  # @param count [Integer] how much data to lice
+  # @param offset [Integer] the offset to start at
+  #
+  # @return [String] the substring
   def substring(count, offset = 0)
     `#@native.substringData(offset, count)`
   end