atome-opal-browser 0.3.9.5

data/opal/browser/event.rb

@@ -0,0 +1,162 @@
+require 'browser/event/base'
+
+module Browser
+
+class Event
+  def self.aliases
+    @aliases ||= {
+      'dom:load' => 'DOMContentLoaded',
+      'hover'    => 'mouse:over'
+    }
+  end
+
+  def self.name_for(name)
+    (aliases[name] || name).gsub(?:, '')
+  end
+
+  def self.handlers
+    @handlers ||= {}
+  end
+
+  def self.handles(*events)
+    events.each { |event| Event.handlers[event] = self }
+  end
+
+  # Those events don't have interesting properties to warrant a custom class
+  # or are not currently implemented.
+  handles 'abort', 'afterprint', 'beforeprint', 'cached', 'canplay',
+          'canplaythrough', 'change', 'chargingchange', 'chargingtimechange',
+          'checking', 'close', 'dischargingtimechange', 'DOMContentLoaded',
+          'downloading', 'durationchange', 'emptied', 'ended', 'error',
+          'fullscreenchange', 'fullscreenerror', 'input', 'invalid',
+          'levelchange', 'loadeddata', 'loadedmetadata', 'noupdate', 'obsolete',
+          'offline', 'online', 'open', 'orientationchange', 'pause',
+          'pointerlockchange', 'pointerlockerror', 'play', 'playing',
+          'ratechange', 'readystatechange', 'reset', 'seeked', 'seeking',
+          'stalled', 'submit', 'success', 'suspend', 'timeupdate', 'updateready',
+          'visibilitychange', 'volumechange', 'waiting'
+
+  def self.class_for(name)
+    @handlers[name_for(name)] || Custom
+  end
+
+  def self.supported?
+    true
+  end
+
+  def self.create(name, *args, &block)
+    name  = name_for(name)
+    klass = class_for(name)
+
+    event = klass.new(klass.construct(name, klass.const_get(:Definition).new(&block)))
+    event.arguments = args
+
+    event
+  end
+
+  if Browser.supports? 'Event.constructor'
+    def self.construct(name, desc)
+      `new Event(#{name}, #{desc})`
+    end
+  elsif Browser.supports? 'Event.create'
+    def self.construct(name, desc)
+      %x{
+        var event = document.createEvent("HTMLEvents");
+            event.initEvent(name, desc.bubbles, desc.cancelable);
+
+        #{return Native(`event`).merge!(desc)};
+      }
+    end
+  elsif Browser.supports? 'Event.createObject'
+    def self.construct(name, desc)
+      Native(`document.createEventObject()`) \
+        .merge!(desc) \
+        .merge!(`{ type: name }`) \
+        .to_n
+    end
+  else
+    def self.construct(name, desc)
+      Native(desc).merge!(`{ type: name }`).to_n
+    end
+  end
+
+  def self.new(value, callback = nil)
+    return super unless self == Event
+
+    klass = class_for(callback ? callback.name : `value.type`)
+
+    if klass == Event
+      super
+    else
+      klass.new(value, callback)
+    end
+  end
+
+  attr_reader :callback
+  attr_writer :on
+
+  def initialize(event, callback = nil)
+    super(event)
+    @callback = callback
+  end
+
+  def name
+    `#@native.type`
+  end
+
+  def on
+    @on || Target.convert(`#@native.currentTarget`)
+  end
+
+  def target
+    Target.convert(`#@native.srcElement || #@native.target`)
+  end
+
+  def arguments
+    `#@native.arguments || []`
+  end
+
+  def arguments=(args)
+    `#@native.arguments = #{args}`
+  end
+
+  alias_native :bubbles?, :bubbles
+  alias_native :cancelable?, :cancelable
+  alias_native :data
+  alias_native :phase, :eventPhase
+  alias_native :at, :timeStamp
+
+  def off
+    @callback.off if @callback
+  end
+
+  def stopped?
+    `!!#@native.stopped`
+  end
+
+  def stop
+    `#@native.stopPropagation()` if defined?(`#@native.stopPropagation`)
+    `#@native.stopped = true`
+  end
+
+  def prevent
+    `#@native.preventDefault()` if defined?(`#@native.preventDefault`)
+    `#@native.prevented = true`
+  end
+
+  def prevented?
+    `!!#@native.prevented`
+  end
+
+  def stop!
+    prevent
+    stop
+  end
+end
+
+end
+
+require 'browser/event/ui'
+require 'browser/event/mouse'
+require 'browser/event/keyboard'
+require 'browser/event/custom'

data/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::Wrapper
+  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/opal/browser/form_data.rb

@@ -0,0 +1,225 @@
+module Browser
+
+class FormData
+  include NativeCachedWrapper
+
+  module Converter
+    # Encode as URI component.
+    #
+    # @return [String] the string encoded for usage as URI component
+    def encode(string)
+      `encodeURIComponent(#{string})`
+    end
+
+    # Decode as URI component.
+    #
+    # @return [String] the string decoded as URI component
+    def decode(string)
+      `decodeURIComponent(#{string})`
+    end
+
+    # Encode as URI.
+    #
+    # @return [String] the string encoded as URI
+    def encode_uri(string)
+      `encodeURI(#{string})`
+    end
+
+    # Decode as URI.
+    #
+    # @return [String] the string decoded as URI
+    def decode_uri(string)
+      `decodeURI(#{string})`
+    end
+
+    # Flattens a hash to build a flat array, later to be formatted to
+    # produce a nested query.
+    #
+    # This code should be compatible with what Rack::Utils#build_nested_query [1]
+    # does.
+    #
+    # [1] https://github.com/rack/rack/blob/master/lib/rack/utils.rb
+    def flatten(value, key="")
+      case value
+      when Hash
+        out = []
+        value.each do |k,v|
+          k = "#{key}[#{k}]" if key != ''
+          out += flatten(v,k)
+        end
+        out
+      when Array
+        out = []
+        value.each do |v|
+          k = "#{key}[]"
+          out += flatten(v,k)
+        end
+        out
+      else
+        [[key,value]]
+      end
+    end
+
+    # Converts a flat array to a Hash.
+    #
+    # This code should be compatible with what Rack::Utils#parse_nested_query [1]
+    # does.
+    #
+    # [1] https://github.com/rack/rack/blob/master/lib/rack/utils.rb
+    def unflatten(array)
+      out = {}
+      array.each do |k,v|
+        path = [k.split("[").first] + k.scan(/\[(.*?)\]/).flatten
+        c = out
+
+        set = proc { |v,weak| } # Do nothing for the first level
+
+        path.each do |i|
+          case i
+          when "" # Array
+            set.([], true)
+            set = proc do |v,weak|
+              c << v
+              c = c.last
+            end
+          else # Hash
+            set.({}, true)
+            set = proc do |v,weak|
+              c[i] ||= v
+              c[i] = v if !weak
+              c = c[i]
+            end
+          end
+        end
+        set.(v, false)
+
+      end
+      out
+    end
+
+    # Checks if a query Hash contains any files.
+    def contain_files?(hash)
+      flatten(hash).any? { |k,v| [File, Blob].include?(v.class) }
+    end
+
+    # Convert a query Hash to a query string
+    #
+    # @return [String] the string encoded as URI
+    def build_query(hash, sep=?&)
+      flatten(hash).map { |k,v| encode(k) + ?= + encode(v.to_s) }.join(sep)
+    end
+
+    # Convert a query Hash to a FormData instance
+    #
+    # @return [FormData] the instance of FormData
+    def build_form_data(hash)
+      fd = FormData.create
+      flatten(hash).each { |k,v| fd << [k,v] }
+      fd
+    end
+
+    # Convert a query string to a query Hash
+    #
+    # @return [Hash] the query hash
+    def parse_query(string, sep=?&)
+      unflatten(string.split(sep).map { |s| s.split(?=).map(&method(:decode)) })
+    end
+
+    # Converts a JS native value to a wrapped one if possible.
+    #
+    # @return [String, File, Blob]
+    def from_native(n)
+      %x{
+        var c = #{n}.constructor;
+        if (c === File) {
+          #{n = File.new(n)}
+        }
+        else if (c === Blob) {
+          #{n = Blob.new(n)}
+        }
+      }
+      n
+    end
+  end
+
+  extend Converter
+  include Enumerable
+
+  # Create a new FormData instance
+  def self.create(hash=nil)
+    if Hash === hash
+      FormData.build_form_data(hash)
+    elsif DOM::Element::Form === hash
+      new(`new FormData(#{hash.to_n})`)
+    else
+      new(`new FormData()`)
+    end
+  end
+
+  # Append a tuple to this FormData instance
+  #
+  # @param tuple [Array(String, String), Array(String, Blob), Array(String, File),
+  #               Array(String, Blob, String), Array(String, File, String)]
+  #        a tuple of a key, value and possibly a filename
+  def <<(tuple)
+    key, value, filename = tuple
+
+    unless filename
+      `#@native.append(#{key}, #{Native.convert(value)})`
+    else
+      `#@native.append(#{key}, #{Native.convert(value)}, #{filename})`
+    end
+  end
+
+  # Get a field from this FormData instance with a given name
+  def [](key)
+    FormData.from_native(`#@native.get(#{key})`)
+  end
+
+  # Set a field in this FormData instance with a given name
+  def set(key, value, filename = nil)
+    unless filename
+      `#@native.set(#{key}, #{Native.convert(value)})`
+    else
+      `#@native.set(#{key}, #{Native.convert(value)}, #{filename})`
+    end
+  end
+  alias []= set
+
+  # Convert to hash
+  def to_h
+    hash = {}
+    %x{
+      var pair, v, e = #@native.entries();
+      while (true) {
+        v = e.next();
+        if (v.done) break;
+        pair = v.value;
+        #{hash[`pair[0]`] = FormData.from_native(`pair[1]`)}
+      }
+    }
+    hash
+  end
+
+  # Convert to array
+  def to_a
+    to_h.to_a
+  end
+
+  # Iterate over all elements of this FormData
+  def each(&block)
+    to_h.each(&block)
+  end
+
+  # Checks if a field of this name exists in this FormData instance
+  def include?(key)
+    `#@native.has(#{key})`
+  end
+
+  # Delete a field from this FormData instance
+  def delete(key)
+    `#@native.delete(#{key})`
+  end
+end
+
+end

data/opal/browser/history.rb

@@ -0,0 +1,86 @@
+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 Browser::NativeCachedWrapper
+
+  # @!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)
+    `#@native.pushState(#{data.to_n}, 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)
+    `#@native.replaceState(#{data.to_n}, null, item)`
+  end
+
+  # @!attribute [r] current
+  # @return [String] the current item
+  def current
+    $window.location.full_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

data/opal/browser/http/binary.rb

@@ -0,0 +1,58 @@
+module Browser; module HTTP
+
+# Represents a binary result from a HTTP response.
+class Binary
+  # @!attribute [r] type
+  # @return [:string, :buffer] the type of binary
+  attr_reader :type
+
+  # Create a binary from a value.
+  #
+  # @param value [String, Buffer] the binary
+  def initialize(value)
+    if String === value
+      @type = :string
+      @data = value
+    else
+      @type = :buffer
+      @data = value.to_a
+    end
+  end
+
+  include Enumerable
+
+  # Iterate over each byte in the binary.
+  #
+  # @yield [byte] the byte
+  #
+  # @return [self]
+  def each(&block)
+    return enum_for :each unless block
+
+    index  = 0
+    length = self.length
+
+    while index < length
+      block.call(self[index])
+
+      index += 1
+    end
+
+    self
+  end
+
+  # Access a byte from the binary.
+  #
+  # @return [Integer] a byte
+  def [](index)
+    @type == :string ? `#@data.charCodeAt(index) & 0xff` : @data[index]
+  end
+
+  # @!attribute [r] length
+  # @return [Integer] the length of the binary
+  def length
+    @data.length
+  end
+end
+
+end; end

data/opal/browser/http/headers.rb

@@ -0,0 +1,109 @@
+module Browser; module HTTP
+
+# Represents a single HTTP header.
+Header = Struct.new(:name, :value)
+
+# Represents HTTP headers.
+class Headers
+  # Parse HTTP headers from a string.
+  #
+  # @param string [String] the whole HTTP headers response
+  # @return [Headers] the parsed headers
+  def self.parse(string)
+    self[string.lines.map { |l| l.chomp.split(/\s*:\s*/) }]
+  end
+
+  # Create {Headers} from a hash.
+  #
+  # @param hash [Hash]
+  def self.[](hash)
+    result = new
+
+    hash.each {|name, value|
+      result[name] = value
+    }
+
+    result
+  end
+
+  include Enumerable
+
+  # Create an empty {Headers}.
+  def initialize
+    @hash = Hash.new
+  end
+
+  # Clear the {Headers}.
+  def clear
+    @hash.clear
+  end
+
+  # Enumerate over the headers.
+  #
+  # @yieldparam name [String] the name of the header
+  # @yieldparam value [String] the value of the header
+  #
+  # @return [self]
+  def each(&block)
+    return enum_for :each unless block
+
+    @hash.each {|_, header|
+      block.call [header.name, header.value]
+    }
+
+    self
+  end
+
+  # Get the value of a header.
+  #
+  # @param name [String] the name of the header
+  #
+  # @return [String] the value of the header
+  def [](name)
+    @hash[name.downcase]
+  end
+
+  # Set a value for the header.
+  #
+  # @param name [String] the name of the header
+  # @param value [String] the value of the header
+  def []=(name, value)
+    header = Header.new(name, value)
+
+    @hash[name.downcase] = header
+  end
+
+  # Push a header.
+  #
+  # @param header [Header] the header to push
+  #
+  # @return [self]
+  def <<(header)
+    @hash[header.name.downcase] = header
+
+    self
+  end
+
+  alias push <<
+
+  # Merge in place other headers.
+  #
+  # @param other [Headers, Hash, #each] the headers to merge
+  #
+  # @return [self]
+  def merge!(other)
+    other.each {|name, value|
+      self[name] = value
+    }
+
+    self
+  end
+
+  # @!attribute [r] length
+  # @return [Integer] the number of headers
+  def length
+    @hash.length
+  end
+end
+
+end; end