opal-browser 0.1.0.beta1

data/opal/browser/dom/node_set.rb

@@ -0,0 +1,88 @@
+module Browser; module DOM
+
+class NodeSet
+  attr_reader :document
+
+  def initialize(document, list = [])
+    @document = document
+    @literal  = []
+
+    list.each {|el|
+      if NodeSet === el
+        @literal.concat(el.to_a)
+      else
+        @literal.push DOM(Native.convert(el))
+      end
+    }
+  end
+
+  def method_missing(name, *args, &block)
+    unless @literal.respond_to? name
+      each {|el|
+        el.__send__(name, *args, &block)
+      }
+
+      return self
+    end
+
+    result = @literal.__send__ name, *args, &block
+
+    if `result === #@literal`
+      self
+    elsif Array === result
+      NodeSet.new(@document, result)
+    else
+      result
+    end
+  end
+
+  def dup
+    NodeSet.new(document, to_ary.dup)
+  end
+
+  def filter(expression)
+    NodeSet.new(document, @literal.select { |node| node.matches?(expression) })
+  end
+
+  def after(node)
+    last.after node
+  end
+
+  def at(path)
+    raise NotImplementedError
+  end
+
+  def at_css(*rules)
+    raise NotImplementedError
+  end
+
+  def at_xpath(*paths)
+    raise NotImplementedError
+  end
+
+  def before
+    first.before
+  end
+
+  def children
+    result = NodeSet.new(document)
+
+    each { |n| result.concat(n.children) }
+
+    result
+  end
+
+  def css(*paths)
+    raise NotImplementedError
+  end
+
+  def search(*what)
+    map { |n| n.search(*what) }.flatten.uniq
+  end
+
+  def inspect
+    "#<DOM::NodeSet: #{@literal.inspect[1 .. -2]}"
+  end
+end
+
+end; end

data/opal/browser/dom/text.rb

@@ -0,0 +1,21 @@
+module Browser; module DOM
+
+class Text < CharacterData
+  def self.create(*args)
+    $document.create_text(*args)
+  end
+
+  def whole
+    `#@native.wholeText`
+  end
+
+  def split(offset)
+    `#@native.splitText(offset)`
+  end
+
+  def inspect
+    "#<DOM::Text: #{data}>"
+  end
+end
+
+end; end

data/opal/browser/effects.rb

@@ -0,0 +1,39 @@
+module Browser; module DOM
+
+class Document < Element
+  def active_element
+    DOM(`#@native.activeElement`)
+  end
+end
+
+class Element
+  def show(what = :block)
+    style[:display] = what
+  end
+
+  def hide
+    style[:display] = :none
+  end
+
+  def toggle
+    if style![:display] == :none
+      show
+    else
+      hide
+    end
+  end
+
+  def focus
+    `#@native.focus()`
+  end
+
+  def blur
+    `#@native.blur()`
+  end
+
+  def focused?
+    `#@native.hasFocus`
+  end
+end
+
+end; end

data/opal/browser/event_source.rb

@@ -0,0 +1,67 @@
+module Browser
+
+# This class wraps `EventSource`.
+class EventSource
+  def self.supported?
+    defined? `window.EventSource`
+  end
+
+  include Native
+  include DOM::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/history.rb

@@ -0,0 +1,54 @@
+require 'browser/location'
+
+module Browser
+
+class History
+  include Native
+
+  alias_native :length
+
+  def back(number = 1)
+    `#@native.go(-number)`
+
+    self
+  end
+
+  def forward(number = 1)
+    `#@native.go(number)`
+
+    self
+  end
+
+  def push(url, data = nil)
+    data = `null` if data.nil?
+
+    `#@native.pushState(data, null, url)`
+
+    self
+  end
+
+  def replace(url, data = nil)
+    data = `null` if data.nil?
+
+    `#@native.replaceState(data, null, url)`
+  end
+
+  def current
+    $window.location.path
+  end
+
+  def state
+    `#@native.state`
+  end
+end
+
+class Window
+  # Get the {History} object for this window.
+  #
+  # @return [History]
+  def history
+    History.new(`#@native.history`) if `#@native.history`
+  end
+end
+
+end

data/opal/browser/http.rb

@@ -0,0 +1,129 @@
+require 'promise'
+
+require 'browser/http/binary'
+require 'browser/http/headers'
+require 'browser/http/request'
+require 'browser/http/response'
+require 'browser/http/compatibility'
+
+module Browser
+
+module HTTP
+  # Send an asynchronous request.
+  #
+  # @param method [Symbol] the HTTP method to use
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  # @return [Response] the response
+  def self.send(method, url, data = nil, &block)
+    Promise.new.tap {|promise|
+      Request.new(&block).tap {|req|
+        req.on :success do |res|
+          promise.resolve(res)
+        end
+
+        req.on :failure do |res|
+          promise.reject(res)
+        end
+      }.open(method, url).send(data)
+    }
+  end
+
+  # Send an asynchronous GET request.
+  #
+  # @param url [String] the URL to request
+  # @return [Response] the response
+  def self.get(url, &block)
+    send(:get, url, &block)
+  end
+
+  # Send an asynchronous HEAD request.
+  #
+  # @param url [String] the URL to request
+  # @return [Response] the response
+  def self.head(url, &block)
+    send(:head, url, &block)
+  end
+
+  # Send an asynchrnous POST request.
+  #
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  # @return [Response] the response
+  def self.post(url, data = nil, &block)
+    send(:post, url, data, &block)
+  end
+
+  # Send an asynchronous PUT request.
+  #
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  # @return [Response] the response
+  def self.put(url, data = nil, &block)
+    send(:put, url, data, &block)
+  end
+
+  # Send an asynchronous DELETE request.
+  #
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  # @return [Response] the response
+  def self.delete(url, data = nil, &block)
+    send(:delete, url, data, &block)
+  end
+
+  # Send a synchronous request.
+  #
+  # @param method [Symbol] the HTTP method to use
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  # @return [Response] the response
+  def self.send!(method, url, data = nil, &block)
+    Request.new(&block).open(method, url, false).send(data)
+  end
+
+  # Send a synchronous GET request.
+  #
+  # @param url [String] the URL to request
+  # @return [Response] the response
+  def self.get!(url, &block)
+    send!(:get, url, &block)
+  end
+
+  # Send a synchronous HEAD request.
+  #
+  # @param url [String] the URL to request
+  # @return [Response] the response
+  def self.head!(url, &block)
+    send!(:head, url, &block)
+  end
+
+  # Send a synchronous POST request.
+  #
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  # @return [Response] the response
+  def self.post!(url, data = nil, &block)
+    send!(:post, url, data, &block)
+  end
+
+  # Send a synchronous PUT request.
+  #
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  # @return [Response] the response
+  def self.put!(url, data = nil, &block)
+    send!(:put, url, data, &block)
+  end
+
+  # Send a synchronous DELETE request.
+  #
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  # @return [Response] the response
+  def self.delete!(url, data = nil, &block)
+    send!(:delete, url, data, &block)
+  end
+end
+
+end

data/opal/browser/http/binary.rb

@@ -0,0 +1,57 @@
+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