opal-browser 0.1.0.beta1

data/opal/browser/cookies.rb

@@ -0,0 +1,79 @@
+module Browser
+
+class Cookies
+  include Enumerable
+
+  def initialize(document)
+    @document = document
+
+    @options = {
+      expires: Time.now + 1.day,
+      path:    '',
+      domain:  '',
+      secure:  ''
+    }
+  end
+
+  def options (value = nil)
+    value ? @options.merge!(value) : @options
+  end
+
+  def [] (name)
+    matches = `#@document.cookie`.scan(/#{Regexp.escape(key.encode_uri_component)}=([^;]*)/)
+
+    return if matches.empty?
+
+    result = matches.map {|cookie|
+      JSON.parse(cookie.match(/^.*?=(.*)$/)[1].decode_uri_component)
+    }
+
+    result.length == 1 ? result.first : result
+  end
+
+  def []= (name, value, options = {})
+    `#@document.cookie = #{encode name, value.is_a?(String) ? value : JSON.dump(value), @options.merge(options)}`
+  end
+
+  def delete (name)
+    `#@document.cookie = #{encode name, '', expires: Time.now}`
+  end
+
+  def keys
+    Array(`#@document.cookie.split(/; /)`).map {|cookie|
+      cookie.split(/\s*=\s*/).first
+    }
+  end
+
+  def values
+    keys.map {|key|
+      self[key]
+    }
+  end
+
+  def each
+    keys.each {|key|
+      yield key, self[key]
+    }
+  end
+
+  def clear
+    keys.each {|key|
+      delete key
+    }
+  end
+
+protected
+  def encode (key, value, options = {})
+    result = "#{key.encode_uri_component}=#{value.encode_uri_component}; "
+
+    result += "max-age=#{options[:max_age]}; "        if options[:max_age]
+    result += "expires=#{options[:expires].to_utc}; " if options[:expires]
+    result += "path=#{options[:path]}; "              if options[:path]
+    result += "domain=#{options[:domain]}; "          if options[:domain]
+    result += 'secure'                                if options[:secure]
+
+    result
+  end
+end
+
+end

data/opal/browser/css.rb

@@ -0,0 +1,24 @@
+require 'browser/css/declaration'
+require 'browser/css/style_sheet'
+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.
+  #
+  # @param text [String] the CSS text
+  # @return [Browser::DOM::Element] the create <style> element
+  def CSS(text = nil, &block)
+    style = $document.create_element(:style)
+    style[:type] = 'text/css'
+
+    if block
+      style.inner_text = Paggio.css(&block)
+    else
+      style.inner_text = text
+    end
+
+    style
+  end
+end

data/opal/browser/css/declaration.rb

@@ -0,0 +1,88 @@
+module Browser; module CSS
+
+class Declaration
+  include Native
+  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}`
+
+    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)
+    `#@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.rb

@@ -0,0 +1,48 @@
+module Browser; module CSS
+
+class Rule
+  include Native
+
+  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/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/style_sheet.rb

@@ -0,0 +1,83 @@
+module Browser; module CSS
+
+class StyleSheet
+  include Native
+
+  def initialize(what)
+    if what.is_a? DOM::Element
+      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