diamonds 0.1.5

data/lib/diamonds/opal/browser/event/page_transition.rb

@@ -0,0 +1,23 @@
+module Browser; class Event
+
+class PageTransition < Event
+  def self.supported?
+    Browser.supports? 'Event.PageTransition'
+  end
+
+  class Definition < Definition
+    def persisted=(value)
+      `#@native.persisted = #{value}`
+    end
+  end
+
+  if Browser.supports? 'Event.PageTransition'
+    def self.construct(name, desc)
+      `new PageTransitionEvent(name, desc)`
+    end
+  end if supported?
+
+  alias_native :persisted?, :persisted
+end
+
+end; end

data/lib/diamonds/opal/browser/event/pop_state.rb

@@ -0,0 +1,33 @@
+module Browser; class Event
+
+class PopState < Event
+  def self.supported?
+    Browser.supports? 'Event.PopState'
+  end
+
+  class Definition < Definition
+    def state=(value)
+      `#@native.state = #{value}`
+    end
+  end
+
+  if Browser.supports? 'Event.constructor'
+    def self.construct(name, desc)
+      `new PopStateEvent(#{name}, #{desc})`
+    end
+  elsif Browser.supports? 'Event.create'
+    def self.construct(name, desc)
+      %x{
+        var event = document.createEvent('PopStateEvent');
+            event.initPopStateEvent(name, desc.bubbles, desc.cancelable,
+              desc.state);
+
+        return event;
+      }
+    end
+  end if supported?
+
+  alias_native :state
+end
+
+end; end

data/lib/diamonds/opal/browser/event/progress.rb

@@ -0,0 +1,43 @@
+module Browser; class Event
+
+class Progress < Event
+  def self.supported?
+    Browser.supports? 'Event.Progress'
+  end
+
+  class Definition < Definition
+    def computable=(value)
+      `#@native.computableLength = #{value}`
+    end
+
+    def loaded=(value)
+      `#@native.loaded = #{value}`
+    end
+
+    def total=(value)
+      `#@native.total = #{value}`
+    end
+  end
+
+  if Browser.supports? 'Event.constructor'
+    def self.construct(name, desc)
+      `new ProgressEvent(#{name}, #{desc})`
+    end
+  elsif Browser.supports? 'Event.create'
+    def self.construct(name, desc)
+      %x{
+        var event = document.createEvent("ProgressEvent");
+            event.initProgressEvent(name, desc.bubbles, desc.cancelable,
+              desc.computable, desc.loaded, desc.total);
+
+        return event;
+      }
+    end
+  end if supported?
+
+  alias_native :computable?, :computableLength
+  alias_native :loaded
+  alias_native :total
+end
+
+end; end

data/lib/diamonds/opal/browser/event/sensor.rb

@@ -0,0 +1,15 @@
+module Browser; class Event
+
+class Sensor < Event
+  def self.supported?
+    Browser.supports? 'Event.Sensor'
+  end
+
+  if Browser.supports? 'Event.constructor'
+    def self.construct(name, desc)
+      `new SensorEvent(#{name}, #{desc})`
+    end
+  end if supported?
+end
+
+end; end

data/lib/diamonds/opal/browser/event/storage.rb

@@ -0,0 +1,43 @@
+module Browser; class Event
+
+class Storage < Event
+  def self.supported?
+    Browser.supports? 'Event.Storage'
+  end
+
+  class Definition < Definition
+    def key=(value)
+      `#@native.key = #{value}`
+    end
+
+    def new=(value)
+      `#@native.newValue = #{value}`
+    end
+
+    def old=(value)
+      `#@native.oldValue = #{value}`
+    end
+
+    def area=(value)
+      `#@native.storageArea = #{value}`
+    end
+
+    def url=(value)
+      `#@native.url = #{value}`
+    end
+  end
+
+  if Browser.supports? 'Event.constructor'
+    def self.construct(name, desc)
+      `new StorageEvent(#{name}, #{desc})`
+    end
+  end if supported?
+
+  alias_native :key
+  alias_native :new, :newValue
+  alias_native :old, :oldValue
+  alias_native :area, :storageArea
+  alias_native :url
+end
+
+end; end

data/lib/diamonds/opal/browser/event/touch.rb

@@ -0,0 +1,60 @@
+module Browser; class Event
+
+class Touch < Event
+  def self.supported?
+    Browser.supports? 'Event.Touch'
+  end
+
+  class Definition < Definition
+    def alt!
+      `#@native.altKey = true`
+    end
+
+    def ctrl!
+      `#@native.ctrlKey = true`
+    end
+
+    def meta!
+      `#@native.metaKey = true`
+    end
+
+    def shift!
+      `#@native.shiftKey = true`
+    end
+  end
+
+  if Browser.supports? 'Event.constructor'
+    def self.construct(name, desc)
+      `new TouchEvent(#{name}, #{desc})`
+    end
+  end if supported?
+
+  alias_native :alt?, :altKey
+  alias_native :ctrl?, :ctrlKey
+  alias_native :meta?, :metaKey
+  alias_native :shift?, :shiftKey
+
+  # TODO: implement touches and targetTouches
+
+  def cancel?
+    name.downcase == 'touchcancel'
+  end
+
+  def end?
+    name.downcase == 'touchend'
+  end
+
+  def leave?
+    name.downcase == 'touchleave'
+  end
+
+  def move?
+    name.downcase == 'touchmove'
+  end
+
+  def start?
+    name.downcase == 'touchstart'
+  end
+end
+
+end; end

data/lib/diamonds/opal/browser/event/ui.rb

@@ -0,0 +1,38 @@
+module Browser; class Event
+
+class UI < Event
+  def self.supported?
+    Browser.supports? 'Event.UI'
+  end
+
+  class Definition < Definition
+    def detail=(value)
+      `#@native.detail = #{value}`
+    end
+
+    def view=(value)
+      `#@native.view = #{value}`
+    end
+  end
+
+  if Browser.supports? 'Event.constructor'
+    def self.construct(name, desc)
+      `new UIEvent(#{name}, #{desc})`
+    end
+  elsif Browser.supports? 'Event.create'
+    def self.construct(name, desc)
+      %x{
+        var event = document.createEvent("UIEvent");
+            event.initUIEvent(name, desc.bubbles, desc.cancelable,
+              desc.view || window, desc.detail || 0);
+
+        return event;
+      }
+    end
+  end if supported?
+
+  alias_native :detail
+  alias_native :view
+end
+
+end; end

data/lib/diamonds/opal/browser/event/wheel.rb

@@ -0,0 +1,49 @@
+module Browser; class Event
+
+class Wheel < UI
+  def self.supported?
+    not $$[:WheelEvent].nil?
+  end
+
+  class Definition < Definition
+    def x=(value)
+      `#@native.deltaX = #{value}`
+    end
+
+    def y=(value)
+      `#@native.deltaY = #{value}`
+    end
+
+    def z=(value)
+      `#@native.deltaZ = #{value}`
+    end
+
+    def mode=(value)
+      value = case value
+        when :pixel then `WheelEvent.DOM_DELTA_PIXEL`
+        when :line  then `WheelEvent.DOM_DELTA_LINE`
+        when :page  then `WheelEvent.DOM_DELTA_PAGE`
+      end
+
+      `#@native.deltaMode = #{value}`
+    end
+  end
+
+  def self.construct(name, desc)
+    `new WheelEvent(#{name}, #{desc})`
+  end
+
+  alias_native :x, :deltaX
+  alias_native :y, :deltaY
+  alias_native :z, :deltaZ
+
+  def mode
+    case `#@native.deltaMode`
+      when `WheelEvent.DOM_DELTA_PIXEL` then :pixel
+      when `WheelEvent.DOM_DELTA_LINE`  then :line
+      when `WheelEvent.DOM_DELTA_PAGE`  then :page
+    end
+  end
+end
+
+end; end

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

@@ -0,0 +1,70 @@
+module Browser
+
+# An {EventSource} allows you to receive events from a server in real-time,
+# similar to long-polling but not exactly.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/EventSource
+class EventSource
+  def self.supported?
+    Browser.supports? :EventSource
+  end
+
+  include Native
+  include Event::Target
+
+  target {|value|
+    EventSource.new(value) if Native.is_a?(value, `window.EventSource`)
+  }
+
+  # Create an {EventSource} on the given path.
+  #
+  # @param path [String] the path to use as source
+  # @yield if the block has no parameters it's instance_exec'd, otherwise it's
+  #        called with self
+  def initialize(path, &block)
+    if native?(path)
+      super(path)
+    else
+      super(`new window.EventSource(path)`)
+    end
+
+    if block.arity == 0
+      instance_exec(&block)
+    else
+      block.call(self)
+    end if block
+  end
+
+  # @!attribute [r] url
+  # @return [String] the URL of the event source
+  alias_native :url
+
+  # @!attribute [r] state
+  # @return [:connecting, :open, :closed] the state of the event source
+  def state
+    %x{
+      switch (#@native.readyState) {
+        case window.EventSource.CONNECTING:
+          return "connecting";
+
+        case window.EventSource.OPEN:
+          return "open";
+
+        case window.EventSource.CLOSED:
+          return "closed";
+      }
+    }
+  end
+
+  # Check if the event source is alive.
+  def alive?
+    state == :open
+  end
+
+  # Close the event source.
+  def close
+    `#@native.close()`
+  end
+end
+
+end

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

@@ -0,0 +1,90 @@
+require 'browser/location'
+
+module Browser
+
+# {History} allows manipulation of the session history.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/History
+class History
+  # Check if HTML5 history is supported.
+  def self.supported?
+    Browser.supports? 'History'
+  end
+
+  include Native
+
+  # @!attribute [r] length
+  # @return [Integer] how many items are in the history
+  alias_native :length
+
+  # Go back in the history.
+  #
+  # @param number [Integer] how many items to go back
+  def back(number = 1)
+    `#@native.go(-number)`
+  end
+
+  # Go forward in the history.
+  #
+  # @param number [Integer] how many items to go forward
+  def forward(number = 1)
+    `#@native.go(number)`
+  end
+
+  # Push an item in the history.
+  #
+  # @param item [String] the item to push in the history
+  # @param data [Object] additional state to push
+  def push(item, data = nil)
+    data = `null` if data.nil?
+
+    `#@native.pushState(data, null, item)`
+  end
+
+  # Replace the current history item with another.
+  #
+  # @param item [String] the item to replace with
+  # @param data [Object] additional state to replace
+  def replace(item, data = nil)
+    data = `null` if data.nil?
+
+    `#@native.replaceState(data, null, item)`
+  end
+
+  # @!attribute [r] current
+  # @return [String] the current item
+  def current
+    $window.location.path
+  end
+
+  # @!attribute [r] state
+  # @return [Object] the current state
+  if Browser.supports? 'History.state'
+    def state
+      %x{
+        var state = #@native.state;
+
+        if (state == null) {
+          return nil;
+        }
+        else {
+          return state;
+        }
+      }
+    end
+  else
+    def state
+      raise NotImplementedError, 'history state unsupported'
+    end
+  end
+end
+
+class Window
+  # @!attribute [r] history
+  # @return [History] the history for this window
+  def history
+    History.new(`#@native.history`) if `#@native.history`
+  end
+end
+
+end