diamonds 0.1.5

data/lib/diamonds/opal/browser/database/sql.rb

@@ -0,0 +1,194 @@
+require 'promise'
+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
+
+  # @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
+
+    # @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
+
+    # @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/lib/diamonds/opal/browser/delay.rb

@@ -0,0 +1,78 @@
+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
+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
+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/lib/diamonds/opal/browser/dom.rb

@@ -0,0 +1,84 @@
+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'
+
+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
+      roots    = Browser::DOM::Builder.new(document, &block).to_a
+
+      if roots.length == 1
+        roots.first
+      else
+        Browser::DOM::NodeSet.new(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
+  # Get the {DOM::Document} for this window.
+  #
+  # @return [DOM::Document]
+  def document
+    DOM(`#@native.document`)
+  end
+end
+
+end
+
+$document = $window.document

data/lib/diamonds/opal/browser/dom/attribute.rb

@@ -0,0 +1,26 @@
+module Browser; module DOM
+
+# Encapsulates an {Element} attribute.
+class Attribute
+  include Native
+
+  # @!attribute [r] name
+  # @return [String] the name of the attribute
+  alias_native :name
+
+  # @!attribute value
+  # @return [String] the value of the attribute
+  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
+
+end; end

data/lib/diamonds/opal/browser/dom/builder.rb

@@ -0,0 +1,88 @@
+# 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
+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
+        return block.call(builder, item)
+      end
+    }
+
+    raise ArgumentError, "cannot build unknown item #{item}"
+  end
+
+  attr_reader :document, :element
+
+  def initialize(document, &block)
+    @document = document
+    @builder  = Paggio::HTML.new(&block)
+    @roots    = @builder.each.map { |e| Builder.build(self, e) }
+  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 inner = `item.inner_html || nil`
+    dom.inner_html = inner
+  else
+    item.each {|child|
+      dom << Builder.build(b, child)
+    }
+  end
+
+  dom
+end
+
+Builder.for DOM::Node do |b, item|
+  item
+end
+
+end; end