atome-opal-browser 0.3.9.5

data/opal/browser/canvas.rb

@@ -0,0 +1,335 @@
+require 'browser/canvas/style'
+require 'browser/canvas/text'
+require 'browser/canvas/data'
+require 'browser/canvas/gradient'
+
+module Browser
+
+class Canvas
+  include Native::Wrapper
+
+  attr_reader :element, :style, :text
+
+  def initialize(*args)
+    if DOM::Element === args.first
+      element = args.shift
+
+      if DOM::Element::Image === element
+        @image   = element
+      else
+        @element = element
+      end
+    elsif Canvas === args.first
+      @image = args.first
+    end
+
+    unless @element
+      @element = $document.create_element('canvas')
+
+      if @image
+        @element[:width]  = @image.width
+        @element[:height] = @image.height
+      else
+        @element[:width]  = args.shift
+        @element[:height] = args.shift
+      end
+    end
+
+    if @element.node_name != 'CANVAS'
+      raise ArgumentError, "the element isn't a <canvas> element"
+    end
+
+    super(`#{@element.to_n}.getContext('2d')`)
+
+    @style = Style.new(self)
+    @text  = Text.new(self)
+
+    if @image
+      draw_image(@image)
+    end
+  end
+
+  def width
+    @element[:width].to_i
+  end
+
+  def height
+    @element[:height].to_i
+  end
+
+  def width=(new_width)
+    @element[:width] = new_width.to_i
+  end
+
+  def height=(new_height)
+    @element[:height] = new_height.to_i
+  end
+
+  def append_to(parent)
+    @element.append_to(parent)
+  end
+
+  def load(path)
+    promise = Promise.new
+    image   = $document.create_element('img')
+
+    image.on :load do
+      promise.resolve(image)
+    end
+
+    image[:src] = path
+
+    promise
+  end
+
+  def data(x = nil, y = nil, width = nil, height = nil)
+    x      ||= 0
+    y      ||= 0
+    width  ||= self.width
+    height ||= self.height
+
+    Data.new(self, x, y, width, height)
+  end
+
+  def pattern(image, type = :repeat)
+    `#@native.createPattern(#{DOM(image).to_n}, type)`
+  end
+
+  def gradient(*args, &block)
+    Gradient.new(self, *args, &block)
+  end
+
+  def clear(x = nil, y = nil, width = nil, height = nil)
+    x      ||= 0
+    y      ||= 0
+    width  ||= self.width
+    height ||= self.height
+
+    `#@native.clearRect(x, y, width, height)`
+  end
+
+  def begin
+    `#@native.beginPath()`
+
+    self
+  end
+
+  def close
+    `#@native.closePath()`
+
+    self
+  end
+
+  def save
+    `#@native.save()`
+
+    self
+  end
+
+  def restore
+    `#@native.restore()`
+
+    self
+  end
+
+  def move_to(x, y)
+    `#@native.moveTo(x, y)`
+
+    self
+  end
+
+  alias move move_to
+
+  def line_to(x, y)
+    `#@native.lineTo(x, y)`
+
+    self
+  end
+
+  def line(x1, y1, x2, y2)
+    move_to x1, y1
+    line_to x2, y2
+  end
+
+  def rect(x, y, width, height)
+    `#@native.rect(x, y, width, height)`
+
+    self
+  end
+
+  def arc(x, y, radius, angle, clockwise = false)
+    `#@native.arc(x, y, radius, #{angle[:start]}, #{angle[:end]}, !clockwise)`
+
+    self
+  end
+
+  def quadratic_curve_to(cp1x, cp1y, x, y)
+    `#@native.quadraticCurveTo(cp1x, cp1y, x, y)`
+
+    self
+  end
+
+  def bezier_curve_to(cp1x, cp1y, cp2x, cp2y, x, y)
+    `#@native.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y)`
+
+    self
+  end
+
+  def curve_to(*args)
+    case args.length
+    when 4 then quadratic_curve_to(*args)
+    when 6 then bezier_curve_to(*args)
+
+    else raise ArgumentError, "don't know where to dispatch"
+    end
+
+    self
+  end
+
+  def draw_image(image, *args)
+    if Canvas === image
+      image = image.element
+    else
+      image = DOM(image)
+    end
+
+    if args.first.is_a?(Hash)
+      source, destination = args
+
+      `#@native.drawImage(#{image.to_n}, #{source[:x]}, #{source[:y]}, #{source[:width]}, #{source[:height]}, #{destination[:x]}, #{destination[:y]}, #{destination[:width]}, #{destination[:height]})`
+    else
+      case args.length
+      when 0
+        `#@native.drawImage(#{image.to_n}, 0, 0)`
+
+      when 2
+        `#@native.drawImage(#{image.to_n}, #{args[0]}, #{args[1]})`
+
+      when 4
+        `#@native.drawImage(#{image.to_n}, #{args[0]}, #{args[1]}, #{args[2]}, #{args[3]})`
+      end
+    end
+
+    self
+  end
+
+  def translate(x, y, &block)
+    if block
+      save
+
+      `#@native.translate(x, y)`
+
+      instance_eval(&block)
+
+      restore
+    else
+      `#@native.translate(x, y)`
+    end
+
+    self
+  end
+
+  def rotate(angle, &block)
+    if block
+      save
+
+      `#@native.rotate(angle)`
+
+      instance_eval(&block)
+
+      restore
+    else
+      `#@native.rotate(angle)`
+    end
+
+    self
+  end
+
+  def scale(x, y, &block)
+    if block
+      save
+
+      `#@native.scale(x, y)`
+
+      instance_eval(&block)
+
+      restore
+    else
+      `#@native.scale(x, y)`
+    end
+
+    self
+  end
+
+  def transform(m11, m12, m21, m22, dx, dy, &block)
+    if block
+      save
+
+      `#@native.transform(m11, m12, m21, m22, dx, dy)`
+
+      instance_eval(&block)
+
+      restore
+    else
+      `#@native.transform(m11, m12, m21, m22, dx, dy)`
+    end
+
+    self
+  end
+
+  def path(&block)
+    `#@native.beginPath()`
+
+    instance_eval(&block)
+
+    `#@native.closePath()`
+
+    self
+  end
+
+  def fill(&block)
+    path(&block) if block
+
+    `#@native.fill()`
+
+    self
+  end
+
+  def stroke(&block)
+    path(&block) if block
+
+    `#@native.stroke()`
+
+    self
+  end
+
+  def clip(&block)
+    path(&block) if block
+
+    `#@native.clip()`
+
+    self
+  end
+
+  def point_in_path?(x, y)
+    `#@native.isPointInPath(x, y)`
+  end
+
+  def to_data(type = undefined)
+    `#{@element.to_n}.toDataUrl(type)`
+  end
+
+  def to_dom(*)
+    @element
+  end
+
+  def on(*args, &block); @element.on(*args, &block); end
+  def one(*args, &block); @element.one(*args, &block); end
+  def off(*args, &block); @element.off(*args, &block); end
+end
+
+Browser::DOM::Builder.for Canvas do |b, item|
+  item.element
+end
+
+end

data/opal/browser/console.rb

@@ -0,0 +1,105 @@
+warn "`console' has been moved to Opal's stdlib, please `require 'console'` instead." if RUBY_ENGINE_VERSION.to_f >= 0.9
+
+module Browser
+
+# Manipulate the browser console.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/console
+class Console
+  include Browser::NativeCachedWrapper
+
+  # Clear the console.
+  def clear
+    `#@native.clear()`
+  end
+
+  # Print a stacktrace from the call site.
+  def trace
+    `#@native.trace()`
+  end
+
+  # Log the passed objects based on an optional initial format.
+  def log(*args)
+    `#@native.log.apply(#@native, args)`
+  end
+
+  # Log the passed objects based on an optional initial format as informational
+  # log.
+  def info(*args)
+    `#@native.info.apply(#@native, args)`
+  end
+
+  # Log the passed objects based on an optional initial format as warning.
+  def warn(*args)
+    `#@native.warn.apply(#@native, args)`
+  end
+
+  # Log the passed objects based on an optional initial format as error.
+  def error(*args)
+    `#@native.error.apply(#@native, args)`
+  end
+
+  # Time the given block with the given label.
+  def time(label, &block)
+    raise ArgumentError, "no block given" unless block
+
+    `#@native.time(label)`
+
+    begin
+      if block.arity == 0
+        instance_exec(&block)
+      else
+        block.call(self)
+      end
+    ensure
+      `#@native.timeEnd()`
+    end
+  end
+
+  # Group the given block.
+  def group(*args, &block)
+    raise ArgumentError, "no block given" unless block
+
+    `#@native.group.apply(#@native, args)`
+
+    begin
+      if block.arity == 0
+        instance_exec(&block)
+      else
+        block.call(self)
+      end
+    ensure
+      `#@native.groupEnd()`
+    end
+  end
+
+  # Group the given block but collapse it.
+  def group!(*args, &block)
+    return unless block_given?
+
+    `#@native.groupCollapsed.apply(#@native, args)`
+
+    begin
+      if block.arity == 0
+        instance_exec(&block)
+      else
+        block.call(self)
+      end
+    ensure
+      `#@native.groupEnd()`
+    end
+  end
+end
+
+class Window
+  # Get the {Console} for this window.
+  #
+  # @return [Console]
+  def console
+    Console.new(`#@native.console`)
+  end
+end
+
+$console = $window.console
+
+end

data/opal/browser/cookies.rb

@@ -0,0 +1,171 @@
+module Browser
+
+# Allows manipulation of browser cookies.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/document.cookie
+#
+# Usage:
+#
+#   cookies = $document.cookies
+#   cookies["my-cookie"] = "monster"
+#   cookies.delete("my-cookie")
+#
+# By default, cookies are stored JSON-encoded. You can supply a `raw:` option
+# whenever you need to access/write the cookies in a raw way, eg.
+#
+#   cookies["my-other-cookie", raw: true] = 123
+#
+# You can also set this option while referencing $document.cookies, eg.
+#
+#   cookies = $document.cookies(raw: true)
+#   cookies["my-other-cookie"] = 123
+class Cookies
+  # Default cookie options.
+  DEFAULT = {
+    expires: Time.now + 60 * 60 * 24,
+    secure:  false
+  }
+
+  include Enumerable
+
+  attr_reader :options
+
+  # Create a new {Cookies} wrapper.
+  #
+  # @param document [native] the native document object
+  # @param options [Hash] the default cookie options
+  def initialize(document, options = {})
+    @document = document
+    @options  = DEFAULT.merge(options)
+  end
+
+  # Access the cookie with the given name.
+  #
+  # @param name [String] the name of the cookie
+  # @param options [Hash] the options for the cookie
+  #
+  # @option options [Boolean] :raw     get a raw cookie value, don't encode it with JSON
+  #
+  # @return [Object]
+  def [](name, options = {})
+    options = @options.merge(options)
+
+    matches = `#@document.cookie`.scan(/#{Regexp.escape(FormData.encode(name))}=([^;]*)/)
+
+    return if matches.empty?
+
+    result = matches.flatten.map do |value|
+      if options[:raw]
+        FormData.decode(value)
+      else
+        JSON.parse(FormData.decode(value))
+      end
+    end
+
+    result.length == 1 ? result.first : result
+  end
+
+  # Set a cookie.
+  #
+  # @param name [String] the name of the cookie
+  # @param value [Object] the data to set
+  # @param options [Hash] the options for the cookie
+  #
+  # @option options [Boolean] :raw     don't encode a value with JSON
+  # @option options [Integer] :max_age the max age of the cookie in seconds
+  # @option options [Time]    :expires the expire date
+  # @option options [String]  :path    the path the cookie is valid on
+  # @option options [String]  :domain  the domain the cookie is valid on
+  # @option options [Boolean] :secure  whether the cookie is secure or not
+  def []=(name, options = {}, value)
+    options = @options.merge(options)
+    if options[:raw]
+      string = value.to_s
+    else
+      string = JSON.dump(value)
+    end
+    encoded_value = encode(name, string, options)
+    `#@document.cookie = #{encoded_value}`
+  end
+
+  # Delete a cookie.
+  #
+  # @param name [String] the name of the cookie
+  def delete(name, _options = {})
+    `#@document.cookie = #{encode name, '', expires: Time.now}`
+  end
+
+  # @!attribute [r] keys
+  # @return [Array<String>] all the cookie names
+  def keys(_options = {})
+    Array(`#@document.cookie.split(/; /)`).map do |cookie|
+      cookie.split(/\s*=\s*/).first
+    end
+  end
+
+  # @!attribute [r] values
+  # @return [Array] all the cookie values
+  def values(options = {})
+    options = @options.merge(options)
+    keys.map do |key|
+      self[key, options]
+    end
+  end
+
+  # Enumerate the cookies.
+  #
+  # @yieldparam key [String] the name of the cookie
+  # @yieldparam value [String] the value of the cookie
+  #
+  # @param options [Hash] the options for the cookie
+  #
+  # @option options [Boolean] :raw     don't encode a value with JSON
+  #
+  # @return [self]
+  def each(options = {}, &block)
+    return enum_for :each, options unless block
+    options = @options.merge(options)
+
+    keys.each do |key|
+      yield key, self[key, options]
+    end
+
+    self
+  end
+
+  # Delete all the cookies
+  #
+  # @return [self]
+  def clear(_options = {})
+    keys.each do |key|
+      delete key
+    end
+
+    self
+  end
+
+protected
+  def encode(key, value, options = {})
+    io = []
+
+    io << FormData.encode(key) << ?= << FormData.encode(value) << '; '
+
+    io << 'max-age=' << options[:max_age] << '; '        if options[:max_age]
+    io << 'expires=' << options[:expires].utc << '; '    if options[:expires]
+    io << 'path='    << options[:path] << '; '           if options[:path]
+    io << 'domain='  << options[:domain] << '; '         if options[:domain]
+    io << 'secure'                                       if options[:secure]
+
+    io.join
+  end
+end
+
+class DOM::Document < DOM::Element
+  # @!attribute [r] cookies
+  # @return [Cookies] the cookies for the document
+  def cookies(options = {})
+    Cookies.new(@native, options) if defined?(`#@native.cookie`)
+  end
+end
+
+end

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