opal-browser 0.1.0.beta1 → 0.3.1

data/opal/browser/event/base.rb

@@ -0,0 +1,461 @@
+module Browser
+
+class Event
+  include Native::Wrapper
+
+  # @see https://developer.mozilla.org/en-US/docs/Web/Guide/Events/Creating_and_triggering_events
+  class Definition
+    include Native::Wrapper
+
+    # @private
+    def self.new(&block)
+      data = super(`{ bubbles: true, cancelable: true }`)
+      block.call(data) if block
+
+      data.to_n
+    end
+
+    # Set the event as bubbling.
+    def bubbles=(value)
+      `#@native.bubbles = #{value}`
+    end
+
+    # Set the event as cancelable.
+    def cancelable=(value)
+      `#@native.cancelable = #{value}`
+    end
+  end
+
+  module Target
+    # @private
+    def self.converters
+      @converters ||= []
+    end
+
+    # @private
+    def self.register(&block)
+      converters << block
+    end
+
+    # @private
+    def self.convert(value)
+      return value unless native?(value)
+
+      converters.each {|block|
+        if result = block.call(value)
+          return result
+        end
+      }
+
+      nil
+    end
+
+    def self.included(klass)
+      klass.instance_eval {
+        def self.target(&block)
+          Event::Target.register(&block)
+        end
+      }
+    end
+
+    class Callback
+      attr_reader :target, :name, :selector
+
+      # @private
+      def initialize(target, name, selector = nil, &block)
+        @target   = target
+        @name     = name
+        @selector = selector
+        @block    = block
+      end
+
+      # Call the callback with the given event.
+      #
+      # @param event [native] the native event object
+      def call(event)
+        to_proc.call(event)
+      end
+
+      # Get the native function linked to the callback.
+      def to_proc
+        @proc ||= -> event {
+          %x{
+            if (!event.currentTarget) {
+              event.currentTarget = self.target.native;
+            }
+          }
+
+          event = Event.new(event, self)
+
+          unless event.stopped?
+            @block.call(event, *event.arguments)
+          end
+
+          !event.prevented?
+        }
+      end
+
+      # @!attribute [r] event
+      # @return [Class] the class for the event
+      def event
+        Event.class_for(@name)
+      end
+
+      # Stop listening for the event linked to the callback.
+      def off
+        target.off(self)
+      end
+    end
+
+    class Delegate
+      def initialize(target, name, pair)
+        @target = target
+        @name   = name
+        @pair   = pair
+      end
+
+      # Stop listening for the event linked to the delegate.
+      def off
+        delegate = @target.delegated[@name]
+        delegate.last.delete(@pair)
+
+        if delegate.last.empty?
+          delegate.first.off
+          delegate.delete(@name)
+        end
+      end
+    end
+
+    Delegates = Struct.new(:callback, :handlers)
+
+    # @overload on(name, &block)
+    #
+    #   Start listening for an event on the target.
+    #
+    #   @param name [String] the event name
+    #
+    #   @yieldparam event [Event] the event
+    #
+    #   @return [Callback]
+    #
+    # @overload on(name, selector, &block)
+    #
+    #   Start listening for an event on the target children.
+    #
+    #   @param name [String] the event name
+    #   @param selector [String] the CSS selector to trigger the event on
+    #
+    #   @yieldparam event [Event] the event
+    #
+    #   @return [Delegate]
+    def on(name, selector = nil, &block)
+      raise ArgumentError, 'no block has been given' unless block
+
+      name = Event.name_for(name)
+
+      if selector
+        unless delegate = delegated[name]
+          delegate = delegated[name] = Delegates.new
+
+          if %w[blur focus].include?(name)
+            delegate.callback = on! name do |e|
+              delegate(delegate, e)
+            end
+          else
+            delegate.callback = on name do |e|
+              delegate(delegate, e)
+            end
+          end
+
+          pair = [selector, block]
+          delegate.handlers = [pair]
+
+          Delegate.new(self, name, pair)
+        else
+          pair = [selector, block]
+          delegate.handlers << pair
+
+          Delegate.new(self, name, pair)
+        end
+      else
+        callback = Callback.new(self, name, selector, &block)
+        callbacks.push(callback)
+
+        attach(callback)
+      end
+    end
+
+    # Start listening for an event in the capturing phase.
+    #
+    # @param name [String] the event name
+    #
+    # @yieldparam event [Event] the event
+    #
+    # @return [Callback]
+    def on!(name, &block)
+      raise ArgumentError, 'no block has been given' unless block
+
+      name     = Event.name_for(name)
+      callback = Callback.new(self, name, &block)
+      callbacks.push(callback)
+
+      attach!(callback)
+    end
+
+    if Browser.supports? 'Event.addListener'
+      def attach(callback)
+        `#@native.addEventListener(#{callback.name}, #{callback.to_proc})`
+
+        callback
+      end
+
+      def attach!(callback)
+        `#@native.addEventListener(#{callback.name}, #{callback.to_proc}, true)`
+
+        callback
+      end
+    elsif Browser.supports? 'Event.attach'
+      def attach(callback)
+        if callback.event == Custom
+          %x{
+            if (!#@native.$custom) {
+              #@native.$custom = function(event) {
+                for (var i = 0, length = #@native.$callbacks.length; i < length; i++) {
+                  var callback = #@native.$callbacks[i];
+
+                  if (#{`callback`.event == Custom}) {
+                    event.type = callback.name;
+
+                    #{`callback`.call(`event`)};
+                  }
+                }
+              };
+
+              #@native.attachEvent("ondataavailable", #@native.$custom);
+            }
+          }
+        else
+          `#@native.attachEvent("on" + #{callback.name}, #{callback.to_proc})`
+        end
+
+        callback
+      end
+
+      def attach!(callback)
+        case callback.name
+        when :blur
+          `#@native.attachEvent("onfocusout", #{callback.to_proc})`
+
+        when :focus
+          `#@native.attachEvent("onfocusin", #{callback.to_proc})`
+
+        else
+          warn "attach: capture doesn't work on this browser"
+          attach(callback)
+        end
+
+        callback
+      end
+    else
+      # @todo implement polyfill
+      # @private
+      def attach(*)
+        raise NotImplementedError
+      end
+
+      # @todo implement polyfill
+      # @private
+      def attach!(*)
+        raise NotImplementedError
+      end
+    end
+
+    # @overload one(name, &block)
+    #
+    #   Start listening for an event on the target. Remove the event after firing
+    #   so that it is fired at most once.
+    #
+    #   @param name [String] the event name
+    #
+    #   @yieldparam event [Event] the event
+    #
+    #   @return [Callback]
+    #
+    # @overload one(name, selector, &block)
+    #
+    #   Start listening for an event on the target children. Remove the event after
+    #   firing so that it is fired at most once.
+    #
+    #   @param name [String] the event name
+    #   @param selector [String] the CSS selector to trigger the event on
+    #
+    #   @yieldparam event [Event] the event
+    #
+    #   @return [Delegate]
+    def one (name, selector = nil, &block)
+      raise ArgumentError, 'no block has been given' unless block
+
+      cb = on name, selector do |*args|
+        out = block.call(*args)
+        cb.off
+        out
+      end
+    end
+    # @overload off()
+    #   Stop listening for any event.
+    #
+    # @overload off(what)
+    #   Stop listening for an event.
+    #
+    #   @param what [Callback, String, Regexp] what to stop listening for
+    def off(what = nil)
+      case what
+      when Callback
+        callbacks.delete(what)
+        detach(what)
+
+      when String
+        if what.include?(?*) or what.include?(??)
+          off(Regexp.new(what.gsub(/\*/, '.*?').gsub(/\?/, ?.)))
+        else
+          what = Event.name_for(what)
+
+          callbacks.delete_if {|callback|
+            if callback.name == what
+              detach(callback)
+
+              true
+            end
+          }
+        end
+
+      when Regexp
+        callbacks.delete_if {|callback|
+          if callback.name =~ what
+            detach(callback)
+
+            true
+          end
+        }
+
+      else
+        callbacks.each {|callback|
+          detach(callback)
+        }
+
+        callbacks.clear
+      end
+    end
+
+    if Browser.supports? 'Event.removeListener'
+      def detach(callback)
+        `#@native.removeEventListener(#{callback.name}, #{callback.to_proc}, false)`
+      end
+    elsif Browser.supports? 'Event.detach'
+      def detach(callback)
+        if callback.event == Custom
+          if callbacks.none? { |c| c.event == Custom }
+            %x{
+              #@native.detachEvent("ondataavailable", #@native.$custom);
+
+              delete #@native.$custom;
+            }
+          end
+        else
+          `#@native.detachEvent("on" + #{callback.name}, #{callback.to_proc})`
+        end
+      end
+    else
+      # @todo implement internal handler thing
+      # @private
+      def detach(callback)
+        raise NotImplementedError
+      end
+    end
+
+    # Trigger an event on the target.
+    #
+    # @param event [String] the event name
+    # @param args [Array] optional arguments to the event callback
+    #
+    # @yieldparam definition [Definition] definition to customize the event
+    def trigger(event, *args, &block)
+      if event.is_a? String
+        event = Event.create(event, *args, &block)
+      end
+
+      dispatch(event)
+    end
+
+    # Trigger an event on the target without bubbling.
+    #
+    # @param event [String] the event name
+    # @param args [Array] optional arguments to the event callback
+    #
+    # @yieldparam definition [Definition] definition to customize the event
+    def trigger!(event, *args, &block)
+      trigger event, *args do |e|
+        block.call(e) if block
+        e.bubbles = false
+      end
+    end
+
+    if Browser.supports? 'Event.dispatch'
+      def dispatch(event)
+        `#@native.dispatchEvent(#{event.to_n})`
+      end
+    elsif Browser.supports? 'Event.fire'
+      def dispatch(event)
+        if Custom === event
+          `#@native.fireEvent("ondataavailable", #{event.to_n})`
+        else
+          `#@native.fireEvent("on" + #{event.name}, #{event.to_n})`
+        end
+      end
+    else
+      # @todo implement polyfill
+      # @private
+      def dispatch(*)
+        raise NotImplementedError
+      end
+    end
+
+  private
+    def callbacks
+      %x{
+        if (!#@native.$callbacks) {
+          #@native.$callbacks = [];
+        }
+
+        return #@native.$callbacks;
+      }
+    end
+
+    def delegated
+      %x{
+        if (!#@native.$delegated) {
+          #@native.$delegated = #{{}};
+        }
+
+        return #@native.$delegated;
+      }
+    end
+
+    def delegate(delegates, event, element = event.target)
+      return if element.nil? || element == event.on
+
+      delegates.handlers.each {|selector, block|
+        if element =~ selector
+          new    = event.dup
+          new.on = element
+
+          block.call new, *new.arguments
+        end
+      }
+
+      delegate(delegates, event, element.parent)
+    end
+  end
+end
+
+end

data/opal/browser/event/before_unload.rb

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

data/opal/browser/event/clipboard.rb

@@ -0,0 +1,37 @@
+module Browser; class Event
+
+class Clipboard < Event
+  handles 'copy', 'cut', 'paste'
+
+  def self.supported?
+    Browser.supports? 'Event.Clipboard'
+  end
+
+  class Definition < Definition
+    def data=(value)
+      `#@native.data = #{value}`
+    end
+
+    def type=(value)
+      `#@native.dataType = #{value}`
+    end
+  end
+
+  if Browser.supports? 'Event.constructor'
+    def self.construct(name, desc)
+      `new ClipboardEvent(#{name}, #{desc})`
+    end
+  end if supported?
+
+  alias_native :data
+  alias_native :type, :dataType
+
+  # Returns a {DataTransfer} related to this event
+  #
+  # @see https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer
+  def transfer
+    DataTransfer.new(`#@native.clipboardData`)
+  end
+end
+
+end; end

data/opal/browser/event/close.rb

@@ -0,0 +1,49 @@
+module Browser; class Event
+
+class Close < Event
+  handles 'close'
+
+  def self.supported?
+    Browser.supports? 'Event.Close'
+  end
+
+  class Definition < Definition
+    def code=(value)
+      `#@native.code = #{value}`
+    end
+
+    def reason=(value)
+      `#@native.reason = #{value}`
+    end
+
+    def clean!(value)
+      `#@native.wasClean = true`
+    end
+
+    def not_clean!(value)
+      `#@native.wasClean = false`
+    end
+  end
+
+  if Browser.supports? 'Event.constructor'
+    def self.construct(name, desc)
+      `new CloseEvent(#{name}, #{desc})`
+    end
+  elsif Browser.supports? 'Event.create'
+    def self.construct(name, desc)
+      %x{
+        var event = document.createEvent("CloseEvent");
+            event.initCloseEvent(name, desc.bubbles, desc.cancelable,
+              desc.wasClean, desc.code, desc.reason);
+
+        return event;
+      }
+    end
+  end if supported?
+
+  alias_native :code
+  alias_native :reason
+  alias_native :clean?, :wasClean
+end
+
+end; end

data/opal/browser/event/composition.rb

@@ -0,0 +1,52 @@
+module Browser; class Event
+
+class Composition < UI
+  handles 'compositionend', 'compositionstart', 'compositionupdate'
+
+  def self.supported?
+    Browser.supports? 'Event.Composition'
+  end
+
+  class Definition < UI::Definition
+    def data=(value)
+      `#@native.data = #{value}`
+    end
+
+    def locale=(value)
+      `#@native.locale = #{value}`
+    end
+  end
+
+  if Browser.supports? 'Event.constructor'
+    def self.construct(name, desc)
+      `new CompositionEvent(#{name}, #{desc})`
+    end
+  elsif Browser.supports? 'Event.create'
+    def self.construct(name, desc)
+      %x{
+        var event = document.createEvent("CompositionEvent");
+            event.initCompositionEvent(name, desc.bubbles, desc.cancelable,
+              desc.view || window, desc.data, desc.locale);
+
+        return event;
+      }
+    end
+  end if supported?
+
+  alias_native :data
+  alias_native :locale
+
+  def start?
+    name.downcase == 'compositionstart'
+  end
+
+  def update?
+    name.downcase == 'compositionupdate'
+  end
+
+  def end?
+    name.downcase == 'compositionend'
+  end
+end
+
+end; end

data/opal/browser/event/custom.rb

@@ -0,0 +1,65 @@
+require 'ostruct'
+
+module Browser; class Event
+
+class Custom < Event
+  def self.supported?
+    Browser.supports? 'Event.Custom'
+  end
+
+  class Definition < Definition
+    def method_missing(name, value)
+      if name.end_with? ?=
+        `#@native[#{name[0 .. -2]}] = value`
+      end
+    end
+  end
+
+  if Browser.supports? 'Event.constructor'
+    def self.construct(name, desc)
+      `return new CustomEvent(name, {
+        bubbles:    desc.bubbles,
+        cancelable: desc.cancelable,
+        detail:     desc })`
+    end
+  elsif Browser.supports? 'Event.create'
+    def self.construct(name, desc)
+      %x{
+        var event = document.createEvent("CustomEvent");
+            event.initCustomEvent(name, desc.bubbles, desc.cancelable, desc);
+
+        return event;
+      }
+    end
+  elsif Browser.supports? 'Event.createObject'
+    def self.construct(name, desc)
+      Native(`document.createEventObject()`).merge!(`{
+        type:       name,
+        bubbles:    desc.bubbles,
+        cancelable: desc.cancelable,
+        detail:     desc }`).to_n
+    end
+  else
+    def self.construct(name, desc)
+      Native(desc).merge!(`{
+        type:       name,
+        bubbles:    desc.bubbles,
+        cancelable: desc.cancelable,
+        detail:     desc }`).to_n
+    end
+  end
+
+  def initialize(event, callback = nil)
+    super(event, callback)
+
+    @detail = Hash.new(`#{event}.detail`)
+  end
+
+  def method_missing(id, *)
+    return @detail[id] if @detail.has_key?(id)
+
+    super
+  end
+end
+
+end; end