diamonds 0.1.5

data/lib/diamonds/opal/browser/canvas/data.rb

@@ -0,0 +1,63 @@
+module Browser; class Canvas
+
+class Data
+  def self.create(canvas, width, height)
+    data = allocate
+
+    data.instance_eval {
+      @canvas = canvas.to_a
+      @x      = 0
+      @y      = 0
+      @width  = width
+      @height = height
+
+      @native = `#{canvas.to_n}.createImageData(width, height)`
+    }
+
+    data
+  end
+
+  include Native
+
+  attr_reader :x, :y, :width, :height
+
+  def initialize(canvas, x, y, width, height)
+    @canvas = canvas.to_n
+    @x      = x
+    @y      = y
+    @width  = width
+    @height = height
+
+    super(`#@canvas.getImageData(x, y, width, height)`)
+  end
+
+  def length
+    `#@native.data.length`
+  end
+
+  def [](index)
+    `#@native.data[index]`
+  end
+
+  def []=(index, value)
+    `#@native.data[index] = value`
+  end
+
+  def save(x = nil, y = nil)
+    x ||= 0
+    y ||= 0
+
+    `#@canvas.putImageData(#@native, x, y)`
+  end
+
+  def save_to(canvas, x = nil, y = nil)
+    x ||= 0
+    y ||= 0
+
+    `#{canvas.to_n}.putImageData(#@native, x, y)`
+  end
+
+  alias size length
+end
+
+end; end

data/lib/diamonds/opal/browser/canvas/gradient.rb

@@ -0,0 +1,27 @@
+module Browser; class Canvas
+
+class Gradient
+  include Native
+
+  attr_reader :context
+
+  def initialize(context, *args, &block)
+    @context = context
+
+    super(case args.length
+      when 4 then `#{@context.to_n}.createLinearGradient.apply(self, args)`
+      when 6 then `#{@context.to_n}.createRadialGradient.apply(self, args)`
+      else raise ArgumentError, "don't know where to dispatch"
+    end)
+
+    instance_eval(&block)
+  end
+
+  def add(position, color)
+    `#{@context.to_n}.addColorStop(position, color)`
+
+    self
+  end
+end
+
+end; end

data/lib/diamonds/opal/browser/canvas/style.rb

@@ -0,0 +1,113 @@
+module Browser; class Canvas
+
+class StyleObject
+  include Native
+
+  attr_reader :context
+
+  def initialize(context)
+    @context = context
+
+    super(@context.to_n)
+  end
+end
+
+class Style < StyleObject
+  class Line < StyleObject
+    attr_reader :width, :cap, :join, :miter_limit
+
+    def width=(value)
+      `#@native.lineWidth = #{@width = value}`
+    end
+
+    def cap=(value)
+      `#@native.lineCap = #{@cap = value}`
+    end
+
+    def join=(value)
+      `#@native.lineJoin = #{@join = value}`
+    end
+
+    def miter_limit=(value)
+      `#@native.miterLimit = #{@miter_limit = value}`
+    end
+  end
+
+  class Text < StyleObject
+    attr_reader :font, :align, :baseline
+
+    def font=(value)
+      `#@native.font = #{@font = value}`
+    end
+
+    def align=(value)
+      `#@native.textAlign = #{@align = value}`
+    end
+
+    def baseline=(value)
+      `#@native.textBaseline = #{@baseline = value}`
+    end
+  end
+
+  class Image < StyleObject
+    attr_reader :smooth
+
+    alias smooth? smooth
+
+    def smooth!
+      `#@native.mozImageSmoothingEnabled = #{@smooth = true}`
+    end
+
+    def no_smooth!
+      `#@native.mozImageSmoothingEnabled = #{@smooth = false}`
+    end
+  end
+
+  class Shadow < StyleObject
+    attr_reader :offset, :blur, :color
+
+    def offset=(value)
+      `#@native.shadowOffsetX = #{value[:x]}`
+      `#@native.shadowOffsetY = #{value[:y]}`
+
+      @offset = value
+    end
+
+    def blur=(value)
+      `#@native.shadowBlur = #{@blur = value}`
+    end
+
+    def color=(value)
+      `#@native.shadowColor = #{@color = value}`
+    end
+  end
+
+  attr_reader :line, :text, :image, :shadow, :fill, :stroke, :alpha, :composite_operation
+
+  def initialize(context)
+    super(context)
+
+    @line   = Line.new(context)
+    @text   = Text.new(context)
+    @image  = Image.new(context)
+    @shadow = Shadow.new(context)
+  end
+
+  def fill=(value)
+    `#@native.fillStyle = #{(@fill = value).to_n}`
+  end
+
+  def stroke=(value)
+    `#@native.strokeStyle = #{(@stroke = value).to_n}`
+  end
+
+  def alpha=(value)
+    `#@native.globalAlpha = #{@alpha = value}`
+  end
+
+  def composite_operation=(value)
+    `#@native.globalCompositeOperation = #{@composite_operation = value}`
+  end
+end
+
+end; end

data/lib/diamonds/opal/browser/canvas/text.rb

@@ -0,0 +1,45 @@
+module Browser; class Canvas
+
+class Text
+  include Native
+
+  attr_reader :context
+
+  def initialize(context)
+    @context = context
+
+    super(@context.to_n)
+  end
+
+  def measure(text)
+    `#@native.measureText(text)`
+  end
+
+  def fill(text, x = nil, y = nil, max_width = nil)
+    x ||= 0
+    y ||= 0
+
+    if max_width
+      `#@native.fillText(text, x, y, max_width)`
+    else
+      `#@native.fillText(text, x, y)`
+    end
+
+    @context
+  end
+
+  def stroke(text, x = nil, y = nil, max_width = nil)
+    x ||= 0
+    y ||= 0
+
+    if max_width
+      `#@native.strokeText(text, x, y, max_width)`
+    else
+      `#@native.strokeText(text, x, y)`
+    end
+
+    @context
+  end
+end
+
+end; end

data/lib/diamonds/opal/browser/console.rb

@@ -0,0 +1,103 @@
+module Browser
+
+# Manipulate the browser console.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/console
+class Console
+  include Native
+
+  # 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/lib/diamonds/opal/browser/cookies.rb

@@ -0,0 +1,133 @@
+require 'stringio'
+
+module Browser
+
+# Allows manipulation of browser cookies.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/document.cookie
+class Cookies
+  # Default cookie options.
+  DEFAULT = {
+    expires: Time.now + 1.day,
+    secure:  false
+  }
+
+  include Enumerable
+
+  attr_reader :options
+
+  # Create a new {Cookies} wrapper.
+  #
+  # @param document [native] the native document object
+  def initialize(document)
+    @document = document
+    @options  = DEFAULT.dup
+  end
+
+  # Access the cookie with the given name.
+  #
+  # @param name [String] the name of the cookie
+  #
+  # @return [Object]
+  def [](name)
+    matches = `#@document.cookie`.scan(/#{Regexp.escape(name.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
+
+  # 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 [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, value, options = {})
+    `#@document.cookie = #{encode name, value.is_a?(String) ? value : JSON.dump(value), @options.merge(options)}`
+  end
+
+  # Delete a cookie.
+  #
+  # @param name [String] the name of the cookie
+  def delete(name)
+    `#@document.cookie = #{encode name, '', expires: Time.now}`
+  end
+
+  # @!attribute [r] keys
+  # @return [Array<String>] all the cookie names
+  def keys
+    Array(`#@document.cookie.split(/; /)`).map {|cookie|
+      cookie.split(/\s*=\s*/).first
+    }
+  end
+
+  # @!attribute [r] values
+  # @return [Array] all the cookie values
+  def values
+    keys.map {|key|
+      self[key]
+    }
+  end
+
+  # Enumerate the cookies.
+  #
+  # @yieldparam key [String] the name of the cookie
+  # @yieldparam value [String] the value of the cookie
+  #
+  # @return [self]
+  def each(&block)
+    return enum_for :each unless block
+
+    keys.each {|key|
+      yield key, self[key]
+    }
+
+    self
+  end
+
+  # Delete all the cookies
+  #
+  # @return [self]
+  def clear
+    keys.each {|key|
+      delete key
+    }
+
+    self
+  end
+
+protected
+  def encode(key, value, options = {})
+    io = StringIO.new
+
+    io << key.encode_uri_component << ?= << value.encode_uri_component << '; '
+
+    io << 'max-age=' << options[:max_age] << '; '        if options[:max_age]
+    io << 'expires=' << options[:expires].to_utc << '; ' if options[:expires]
+    io << 'path='    << options[:path] << '; '           if options[:path]
+    io << 'domain='  << options[:domain] << '; '         if options[:domain]
+    io << 'secure'                                       if options[:secure]
+
+    io.string
+  end
+end
+
+class DOM::Document < DOM::Element
+  # @!attribute [r] cookies
+  # @return [Cookies] the cookies for the document
+  def cookies
+    Cookies.new(@native) if defined?(`#@native.cookie`)
+  end
+end
+
+end