diamonds 0.1.5

data/lib/diamonds/opal/browser/http/response.rb

@@ -0,0 +1,115 @@
+require 'json'
+
+module Browser; module HTTP
+
+# Represents an HTTP response.
+class Response
+  include Native
+
+  Status = Struct.new(:code, :text)
+
+  # @!attribute [r] request
+  # @return [Request] the request to this response
+  attr_reader :request
+
+  # Create a response from a request.
+  #
+  # @param request [Request] the request
+  def initialize(request)
+    super(request.to_n)
+
+    @request = request
+  end
+
+  # @!attribute [r] headers
+  # @return [Headers] the response headers
+  def headers
+    @headers ||= Headers.parse(`#@native.getAllResponseHeaders()`)
+  end
+
+  # @!attribute [r] status
+  # @return [Status] the response status
+  def status
+    Status.new(`#@native.status || nil`, `#@native.statusText || nil`)
+  end
+
+  # Checks if the response was successful
+  def success?
+    if code = status.code
+      code >= 200 && code < 300 || code == 304
+    else
+      false
+    end
+  end
+
+  # Check if the response failed
+  def failure?
+    !success?
+  end
+
+  # @!attribute [r] text
+  # @return [String] the response body as text
+  def text
+    %x{
+      var result = #@native.responseText;
+
+      if (!result) {
+        return nil;
+      }
+
+      return result;
+    }
+  end
+
+  # @!attribute [r] json
+  # @return [Hash, Array] the response body as JSON
+  def json
+    %x{
+      var result = #@native.responseText;
+
+      if (!result) {
+        return nil;
+      }
+
+      return #{JSON.parse(`result`)};
+    }
+  end
+
+  # @!attribute [r] xml
+  # @return [DOM::Document] the response body as DOM document
+  def xml
+    %x{
+      var result = #@native.responseXML;
+
+      if (!result) {
+        return nil;
+      }
+    }
+
+    DOM(`result`)
+  end
+
+  # @!attribute [r] binary
+  # @return [Binary] the response body as binary
+  def binary
+    return unless request.binary?
+
+    if Buffer.supported?
+      %x{
+        var result = #@native.response;
+
+        if (!result) {
+          return nil;
+        }
+      }
+
+      Binary.new(Buffer.new(`result`))
+    else
+      return unless text
+
+      Binary.new(text)
+    end
+  end
+end
+
+end; end

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

@@ -0,0 +1,163 @@
+require 'promise'
+
+module Browser
+
+# Class to easily create and dispatch an immediate call.
+#
+# Immediate calls are deferred function calls that happen as soon as they can
+# be scheduled.
+#
+# Compatibility
+# -------------
+# The compatibility layer will try various implementations in the following
+# order.
+#
+# + [setImmediate](https://developer.mozilla.org/en-US/docs/Web/API/Window.setImmediate)
+# + [postMessage](https://developer.mozilla.org/en-US/docs/Web/API/Window.postMessage)
+# + [readystatechange](https://developer.mozilla.org/en-US/docs/Web/Reference/Events/readystatechange)
+# + [setTimeout](https://developer.mozilla.org/en/docs/Web/API/window.setTimeout)
+#
+# The order has been chosen from best to worst for both performance and
+# preemptiveness.
+class Immediate
+  # Create an immediate for the given function which will be called with the
+  # arguments and block.
+  #
+  # @param func [Proc] the function to call
+  # @param args [Array] the arguments to call it with
+  def initialize(func, args, &block)
+    @aborted   = false
+    @function  = func
+    @arguments = args
+    @block     = block
+  end
+
+  # @!method dispatch
+  #   Dispatch the immediate.
+
+  # @!method prevent
+  #   Prevent the immediate from being called once scheduled.
+  if Browser.supports? 'Immediate'
+    def dispatch
+      @id = `window.setImmediate(function() {
+        #{@function.call(*@arguments, &@block)};
+      })`
+    end
+
+    def prevent
+      `window.clearImmediate(#@id)`
+    end
+  elsif Browser.supports? 'Immediate (Internet Explorer)'
+    def dispatch
+      @id = `window.msSetImmediate(function() {
+        #{@function.call(*@arguments, &@block)};
+      })`
+    end
+
+    def prevent
+      `window.msClearImmediate(#@id)`
+    end
+  elsif Browser.supports? 'Window.send (Asynchronous)'
+    # @private
+    @@tasks  = {}
+
+    # @private
+    @@prefix = "opal.browser.immediate.#{rand(1_000_000)}."
+
+    $window.on :message do |e|
+      if String === e.data && e.data.start_with?(@@prefix)
+        if task = @@tasks.delete(e.data[@@prefix.length .. -1])
+          task[0].call(*task[1], &task[2])
+        end
+      end
+    end
+
+    def dispatch
+      @id          = rand(1_000_000).to_s
+      @@tasks[@id] = [@function, @arguments, @block]
+
+      $window.send "#{@@prefix}#{@id}"
+    end
+
+    def prevent
+      @@tasks.delete(@id)
+    end
+  elsif Browser.supports? 'Event.readystatechange'
+    def dispatch
+      %x{
+        var script = document.createElement("script");
+
+        script.onreadystatechange = function() {
+          if (!#{aborted?}) {
+            #{@function.call(*@arguments, &@block)};
+          }
+
+          script.onreadystatechange = null;
+          script.parentNode.removeChild(script);
+        };
+
+        document.documentElement.appendChild(script);
+      }
+    end
+
+    def prevent; end
+  else
+    def dispatch
+      @id = `window.setTimeout(function() {
+        #{@function.call(*@arguments, &@block)};
+      }, 0)`
+    end
+
+    def prevent
+      `window.clearTimeout(#@id)`
+    end
+  end
+
+  # Abort the immediate.
+  def abort
+    return if aborted?
+
+    @aborted = true
+    prevent
+
+    self
+  end
+
+  # Check if the immediate has been aborted.
+  def aborted?
+    @aborted
+  end
+end
+
+end
+
+module Kernel
+  # (see Immediate.new)
+  def defer(*args, &block)
+    Browser::Immediate.new(block, args).tap(&:dispatch)
+  end
+end
+
+class Proc
+  # (see Immediate.new)
+  def defer(*args, &block)
+    Browser::Immediate.new(self, args, &block).tap(&:dispatch)
+  end
+end
+
+class Promise
+  # Create a promise which will be resolved with the result of the immediate.
+  #
+  # @param args [Array] the arguments the block will be called with
+  def self.defer(*args, &block)
+    new.tap {|promise|
+      proc {
+        begin
+          promise.resolve(block.call(*args))
+        rescue Exception => e
+          promise.reject(e)
+        end
+      }.defer
+    }
+  end
+end

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

@@ -0,0 +1,111 @@
+module Browser
+
+# Allows you to create an interval that executes the function every given
+# seconds.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/Window.setInterval
+class Interval
+  # @!attribute [r] every
+  # @return [Float] the seconds every which the block is called
+  attr_reader :every
+
+  # Create and start an interval.
+  #
+  # @param window [Window] the window to start the interval on
+  # @param time [Float] seconds every which to call the block
+  def initialize(window, time, &block)
+    @window = Native.convert(window)
+    @every  = time
+    @block  = block
+
+    @aborted = false
+  end
+
+  # Check if the interval has been stopped.
+  def stopped?
+    @id.nil?
+  end
+
+  # Check if the interval has been aborted.
+  def aborted?
+    @aborted
+  end
+
+  # Abort the interval, it won't be possible to start it again.
+  def abort
+    `#@window.clearInterval(#@id)`
+
+    @aborted = true
+    @id      = nil
+  end
+
+  # Stop the interval, it will be possible to start it again.
+  def stop
+    return if stopped?
+
+    `#@window.clearInterval(#@id)`
+
+    @stopped = true
+    @id      = nil
+  end
+
+  # Start the interval if it has been stopped.
+  def start
+    raise "the interval has been aborted" if aborted?
+    return unless stopped?
+
+    @id = `#@window.setInterval(#@block, #@every * 1000)`
+  end
+
+  # Call the [Interval] block.
+  def call
+    @block.call
+  end
+end
+
+class Window
+  # Execute the block every given seconds.
+  #
+  # @param time [Float] the seconds between every call
+  #
+  # @return [Interval] the object representing the interval
+  def every(time, &block)
+    Interval.new(@native, time, &block).tap(&:start)
+  end
+
+  # Execute the block every given seconds, you have to call [#start] on it
+  # yourself.
+  #
+  # @param time [Float] the seconds between every call
+  #
+  # @return [Interval] the object representing the interval
+  def every!(time, &block)
+    Interval.new(@native, time, &block)
+  end
+end
+
+end
+
+module Kernel
+  # (see Browser::Window#every)
+  def every(time, &block)
+    $window.every(time, &block)
+  end
+
+  # (see Browser::Window#every!)
+  def every!(time, &block)
+    $window.every!(time, &block)
+  end
+end
+
+class Proc
+  # (see Browser::Window#every)
+  def every(time)
+    $window.every(time, &self)
+  end
+
+  # (see Browser::Window#every!)
+  def every!(time)
+    $window.every!(time, &self)
+  end
+end

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

@@ -0,0 +1,87 @@
+module Browser
+
+# Allows manipulation of a location, usually from {Window} and {DOM::Document}.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/Location
+class Location
+  include Native
+
+  # Change the location.
+  #
+  # @param url [String, #to_s] the URL to go to
+  def assign(url)
+    `#@native.assign(#{url.to_s})`
+  end
+
+  # Replace the current URL.
+  #
+  # @param url [String, #to_s] the URL to go to
+  def replace(url)
+    `#@native.replace(#{url.to_s})`
+  end
+
+  # Reload the page.
+  #
+  # @param force [Boolean] whether to force the reload
+  def reload(force = false)
+    `#@native.reload(force)`
+  end
+
+  # Convert the location to a string.
+  def to_s
+    `#@native.toString()`
+  end
+
+  # @!attribute fragment
+  # @return [String] the hash fragment of the location URI
+  alias_native :fragment, :hash
+  alias_native :fragment=, :hash=
+
+  # @!attribute host
+  # @return [String] the host part of the location URI
+  alias_native :host
+  alias_native :host=
+
+  # @!attribute uri
+  # @return [String] the whole location URI
+  alias_native :uri, :href
+  alias_native :uri=, :href=
+
+  # @!attribute path
+  # @return [String] the path part of the location URI
+  alias_native :path, :pathname
+  alias_native :path=, :pathname=
+
+  # @!attribute port
+  # @return [Integer] the port part of the location URI
+  alias_native :port
+  alias_native :port=
+
+  # @!attribute scheme
+  # @return [String] the scheme part of the location URI
+  alias_native :scheme, :protocol
+  alias_native :scheme=, :protocol=
+
+  # @!attribute query
+  # @return [String] the query part of the location URI
+  alias_native :query, :search
+  alias_native :query=, :search=
+end
+
+class Window
+  # @!attribute [r] location
+  # @return [Location] the location for the window
+  def location
+    Location.new(`#@native.location`) if `#@native.location`
+  end
+end
+
+class DOM::Document < DOM::Element
+  # @!attribute [r] location
+  # @return [Location] the location for the document
+  def location
+    Location.new(`#@native.location`) if `#@native.location`
+  end
+end
+
+end