atome-opal-browser 0.3.9.5

data/opal/browser/css/declaration.rb

@@ -0,0 +1,83 @@
+module Browser; module CSS
+
+class Declaration
+  include Browser::NativeCachedWrapper
+  include Enumerable
+
+  def rule
+    Rule.new(`#@native.parentRule`) if defined?(`#@native.parentRule`)
+  end
+
+  def assign(data)
+    data.each {|name, value|
+      self[name] = value
+    }
+
+    self
+  end
+
+  def replace(string)
+    `#@native.cssText = #{string}`
+  end
+
+  def apply(&block)
+    Paggio::CSS::Definition.new(&block).each {|style|
+      if style.important
+        `#@native.setProperty(#{style.name}, #{style.value}, "important")`
+      else
+        `#@native.setProperty(#{style.name}, #{style.value}, "")`
+      end
+    }
+  end
+
+  def delete(name)
+    `#@native.removeProperty(#{name})`
+  end
+
+  def [](name)
+    %x{
+      var result = #@native.getPropertyValue(#{name});
+
+      if (result == null || result === "") {
+        return nil;
+      }
+
+      return result;
+    }
+  end
+
+  def []=(name, value)
+    `#@native.setProperty(#{name}, #{value.to_s}, "")`
+  end
+
+  def important?(name)
+    `#@native.getPropertyPriority(#{name}) == "important"`
+  end
+
+  def each(&block)
+    return enum_for :each unless block_given?
+
+    %x{
+      for (var i = 0, length = #@native.length; i < length; i++) {
+        var name  = #@native.item(i);
+
+        #{yield `name`, self[`name`]}
+      }
+    }
+
+    self
+  end
+
+  alias_native :length
+  alias_native :to_s, :cssText
+
+  def method_missing(name, value = nil)
+    if name.end_with? ?=
+      self[name[0 .. -2]] = value
+    else
+      self[name]
+    end
+  end
+end
+
+end; end

data/opal/browser/css/rule/style.rb

@@ -0,0 +1,16 @@
+module Browser; module CSS; class Rule
+
+class Style < Rule
+  alias_native :selector, :selectorText
+  alias_native :id, :selectorText
+
+  def declaration
+    Declaration.new(`#@native.style`)
+  end
+
+  def method_missing(*args, &block)
+    declaration.__send__(*args, &block)
+  end
+end
+
+end; end; end

data/opal/browser/css/rule.rb

@@ -0,0 +1,48 @@
+module Browser; module CSS
+
+class Rule
+  include Browser::NativeCachedWrapper
+
+  STYLE_RULE               = 1
+  CHARSET_RULE             = 2
+  IMPORT_RULE              = 3
+  MEDIA_RULE               = 4
+  FONT_FACE_RULE           = 5
+  PAGE_RULE                = 6
+  KEYFRAMES_RULE           = 7
+  KEYFRAME_RULE            = 8
+  NAMESPACE_RULE           = 10
+  COUNTER_STYLE_RULE       = 11
+  SUPPORTS_RULE            = 12
+  DOCUMENT_RULE            = 13
+  FONT_FEATURE_VALUES_RULE = 14
+  VIEWPORT_RULE            = 15
+  REGION_STYLE_RULE        = 16
+
+  def self.new(rule)
+    if self == Rule
+      @classes ||= [nil, Style]
+
+      if klass = @classes[`rule.type`]
+        klass.new(rule)
+      else
+        raise ArgumentError, 'cannot instantiate a non derived Rule object'
+      end
+    else
+      super(rule)
+    end
+  end
+
+  alias_native :text, :cssText
+  alias_native :to_s, :cssText
+
+  def parent
+    Rule.new(`#@native.parentRule`) if `#@native.parentRule != null`
+  end
+
+  def style_sheet
+    StyleSheet.new(`#@native.parentStyleSheet`) if `#@native.parentStyleSheet != null`
+  end
+end
+
+end; end

data/opal/browser/css/style_sheet.rb

@@ -0,0 +1,83 @@
+module Browser; module CSS
+
+class StyleSheet
+  include Browser::NativeCachedWrapper
+
+  def initialize(what)
+    if DOM::Element === what
+      super(`#{what.to_n}.sheet`)
+    else
+      super(what)
+    end
+  end
+
+  alias_native :disabled?, :disabled
+  alias_native :href
+  alias_native :title
+  alias_native :type
+
+  def media
+    Media.new(`#@native.media`) if `#@native.media != null`
+  end
+
+  def owner
+    DOM(`#@native.ownerNode`)
+  end
+
+  def parent
+    Sheet.new(`#@native.parentStyleSheet`) if `#@native.parentStyleSheet != null`
+  end
+
+  def rules
+    Native::Array.new(`#@native.cssRules`) { |e|
+      Rule.new(e)
+    }
+  end
+
+  def delete(index)
+    `#@native.deleteRule(index)`
+  end
+
+  def insert(index, rule)
+    `#@native.insertRule(#{rule}, #{index})`
+  end
+
+  def rule(selector, body)
+    unless String === selector
+      selector = selector.join ', '
+    end
+
+    unless String === body
+      body = body.map {|name, value|
+        "#{name}: #{value};"
+      }.join "\n"
+    end
+
+    insert(length, "#{selector} { #{body} }")
+  end
+
+  def [](id)
+    rules.find { |r| log r; r.id == id }
+  end
+
+  def method_missing(*args, &block)
+    rules.__send__(*args, &block)
+  end
+
+  class Media < Native::Array
+    alias_native :text, :mediaText
+    alias_native :to_s, :mediaText
+
+    def push(medium)
+      `#@native.appendMedium(#{medium})`
+
+      self
+    end
+
+    def delete(medium)
+      `#@native.deleteMedium(#{medium})`
+    end
+  end
+end
+
+end; end

data/opal/browser/css/unit.rb

@@ -0,0 +1,188 @@
+module Browser; module CSS
+
+class Unit
+  COMPATIBLE = %i[in pt mm cm px pc]
+
+  attr_reader :type
+
+  def initialize(number, type)
+    @number = number
+    @type   = type
+  end
+
+  def coerce(other)
+    return self, other
+  end
+
+  def ==(other)
+    @number == convert(other, @type)
+  end
+
+  def ===(other)
+    @type == other.type && @number == other.to_f
+  end
+
+  alias eql? ==
+
+  def hash
+    [@number, @type].hash
+  end
+
+  %i[em ex ch rem vh vw vmin vmax px mm cm in pt pc].each {|name|
+    define_method name do
+      Unit.new(convert(self, name), name)
+    end
+  }
+
+  def +(other)
+    return Unit.new(@number + other, @type) unless Unit === other
+
+    if @type == other.type
+      Unit.new(@number + other.to_f, @type)
+    elsif compatible?(self) and compatible?(other)
+      Unit.new(@number + convert(other, @type), @type)
+    else
+      raise ArgumentError, "#{other.type} isn't compatible with #{@type}"
+    end
+  end
+
+  def -(other)
+    return Unit.new(@number - other, @type) unless Unit === other
+
+    if @type == other.type
+      Unit.new(@number - other.to_f, @type)
+    elsif compatible?(self) and compatible?(other)
+      Unit.new(@number - convert(other, @type), @type)
+    else
+      raise ArgumentError, "#{other.type} isn't compatible with #{@type}"
+    end
+  end
+
+  def *(other)
+    return Unit.new(@number * other, @type) unless Unit === other
+
+    if @type == other.type
+      Unit.new(@number * other.to_f, @type)
+    elsif compatible?(self) and compatible?(other)
+      Unit.new(@number * convert(other, @type), @type)
+    else
+      raise ArgumentError, "#{other.type} isn't compatible with #{@type}"
+    end
+  end
+
+  def /(other)
+    return Unit.new(@number / other, @type) unless Unit === other
+
+    if @type == other.type
+      Unit.new(@number / other.to_f, @type)
+    elsif compatible?(self) and compatible?(other)
+      Unit.new(@number / convert(other, @type), @type)
+    else
+      raise ArgumentError, "#{other.type} isn't compatible with #{@type}"
+    end
+  end
+
+  def -@
+    Unit.new(@number * -1, @type)
+  end
+
+  def +@
+    Unit.new(@number, @type)
+  end
+
+  def to_i
+    @number.to_i
+  end
+
+  def to_f
+    @number.to_f
+  end
+
+  def to_u
+    self
+  end
+
+  def to_s
+    "#{@number}#{@type}"
+  end
+
+  alias to_str to_s
+  alias inspect to_s
+
+private
+  def compatible?(unit)
+    COMPATIBLE.include?(unit.type)
+  end
+
+  def convert(unit, type)
+    value = unit.to_f
+
+    return value if unit.type == type
+
+    px = case unit.type
+    when :in then value * 96
+    when :pt then value * 4.0 / 3.0
+    when :pc then value / 12 * 4.0 / 3.0
+    when :mm then value * 3.77953
+    when :cm then value * 10 * 3.77953
+    when :px then value
+    end
+
+    case type
+    when :in then px / 96.0
+    when :pt then px / 4.0 / 3.0
+    when :pc then px * 12 / 4.0 / 3.0
+    when :mm then px / 3.77953
+    when :cm then px / 10 / 3.77953
+    when :px then px
+    end
+  end
+end
+
+end; end
+
+class Numeric
+  Unit = Browser::CSS::Unit
+
+  %i[em ex ch rem vh vw vmin vmax px mm cm in pt pc].each {|name|
+    define_method name do
+      Unit.new(self, name)
+    end
+  }
+
+  alias old_percent %
+
+  def %(other = nil)
+    if other
+      old_percent(other)
+    else
+      Unit.new(self, :%)
+    end
+  end
+
+  def to_u
+    self
+  end
+end
+
+class String
+  def to_u
+    if matches = self.match(/^([\d+.]+)(.+)?$/)
+      value = matches[1].to_f
+
+      if unit = matches[2]
+        value.__send__(unit.downcase)
+      else
+        value
+      end
+    else
+      0
+    end
+  end
+end
+
+class NilClass
+  def to_u
+    0
+  end
+end

data/opal/browser/css.rb

@@ -0,0 +1,40 @@
+require 'browser/css/declaration'
+require 'browser/css/style_sheet'
+require 'browser/css/rule'
+require 'browser/css/rule/style'
+
+module Kernel
+  # @overload CSS(document = $document, &block)
+  #
+  #   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 = args.join("")
+    end
+
+    style
+  end
+end

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