opal-browser 0.1.0.beta1

data/opal/browser/immediate.rb

@@ -0,0 +1,43 @@
+require 'browser/compatibility/immediate'
+
+module Browser
+
+# FIXME: drop the method_defined? checks when require order is fixed
+class Immediate
+  def initialize(func, args, &block)
+    @aborted   = false
+    @function  = func
+    @arguments = args
+    @block     = block
+  end
+
+  def dispatch
+    raise NotImplementedError
+  end unless method_defined? :dispatch
+
+  def prevent
+    raise NotImplementedError
+  end unless method_defined? :prevent
+
+  def abort
+    return if aborted?
+
+    @aborted = true
+    prevent
+
+    self
+  end
+
+  def aborted?
+    @aborted
+  end
+end
+
+end
+
+class Proc
+  # Defer the function to be called as soon as possible.
+  def defer(*args, &block)
+    Browser::Immediate.new(self, args, &block).tap(&:dispatch)
+  end
+end

data/opal/browser/interval.rb

@@ -0,0 +1,93 @@
+module Browser
+
+# This class wraps `setInterval`.
+class Interval
+  # @!attribute [r] every
+  # @return [Number] 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 [Number] seconds every which to call the block
+  def initialize(window, time, &block)
+    @window = Native.convert(window)
+    @every  = time
+    @block  = block
+
+    @aborted = false
+    @stopped = true
+
+    start
+  end
+
+  # Check if the interval has been stopped.
+  def stopped?
+    @stopped
+  end
+
+  # Check if the interval has been aborted.
+  def aborted?
+    @aborted
+  end
+
+  # Abort the interval, it won't be possible to start it again.
+  #
+  # @return [self]
+  def abort
+    `#@window.clearInterval(#@id)`
+
+    @aborted = true
+    @id      = nil
+
+    self
+  end
+
+  # Stop the interval, it will be possible to start it again.
+  #
+  # @return [self]
+  def stop
+    `#@window.clearInterval(#@id)`
+
+    @stopped = true
+    @id      = nil
+  end
+
+  # Start the interval if it has been stopped.
+  #
+  # @return [self]
+  def start
+    raise "the interval has been aborted" if aborted?
+
+    return unless stopped?
+
+    @id = `#@window.setInterval(#{@block.to_n}, #@every * 1000)`
+
+    self
+  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)
+  end
+end
+
+end
+
+class Proc
+  def every(time)
+    $window.every(time, &self)
+  end
+end
+
+module Kernel
+  # (see Browser::Window#every)
+  def every(time, &block)
+    $window.every(time, &block)
+  end
+end

data/opal/browser/location.rb

@@ -0,0 +1,77 @@
+module Browser
+
+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
+  # Get the {Location} object for this window.
+  #
+  # @return [Location]
+  def location
+    Location.new(`#@native.location`) if `#@native.location`
+  end
+end
+
+end

data/opal/browser/navigator.rb

@@ -0,0 +1,151 @@
+module Browser
+
+# Class that represents the browser attributes.
+class Navigator
+  include Native
+
+  Version = Struct.new(:major, :minor, :build)
+  Product = Struct.new(:name, :version)
+  Vendor  = Struct.new(:name, :version)
+
+  # Class that represents a MIME type.
+  class MimeType
+    include Native
+
+    # @!attribute [r] plugin
+    # @return [Plugin] the plugin for the MIME type
+    def plugin
+      Plugin.new(`#@native.enabledPlugin`)
+    end
+
+    # @!attribute [r] description
+    # @return [String] the description for the MIME type
+    alias_native :description
+
+    # @!attribute [r] extensions
+    # @return [Array<String>] the extensions for this MIME type
+    def extensions
+      `#@native.suffixes`.split(/\s*/)
+    end
+
+    # @!attribute [r] type
+    # @return [String] the MIME type
+    alias_native :type
+  end
+
+  # Class to represent a browser plugin.
+  class Plugin < Native::Array
+    def initialize(plugin)
+      super plugin do |m|
+        MimeType.new(m)
+      end
+    end
+
+    # @!attribute [r] description
+    # @return [String] the plugin description
+    alias_native :description
+
+    # @!attribute [r] file
+    # @return [String] the file associated with the plugin
+    alias_native :file, :filename
+
+    # @!attribute [r] name
+    # @return [String] the plugin name
+    alias_native :name
+
+    # @!attribute [r] version
+    # @return [String] the plugin version
+    alias_native :version
+  end
+
+  # @!attribute [r] code
+  # @return [String] the browser code name
+  alias_native :code, :appCodeName
+
+  # @!attribute [r] name
+  # @return [String] the browser name
+  alias_native :name, :appName
+
+  # @!attribute [r] version
+  # @return [Version] the browser version
+  def version
+    Version.new(`#@native.appVersion`, `#@native.appMinorVersion`, `#@native.buildID`)
+  end
+
+  # Check if cookies are enabled.
+  alias_native :cookies?, :cookieEnabled
+
+  # Check if DNT is disabled.
+  def track?
+    `!#@native.doNotTrack`
+  end
+
+  # @!attribute [r] language
+  # @return [String] the browser language
+  alias_native :language
+
+  # @!attribute [r] mime_types
+  # @return [Native::Array<MimeType>] the supported MIME types
+  def mime_types
+    Native::Array.new `#@native.mimeTypes`, get: :item, named: :namedItem do |m|
+      MimeType.new(m)
+    end
+  end
+
+  # Check if the browser is in offline mode.
+  def offline?
+    `!#@native.onLine`
+  end
+
+  # @!attribute [r] operating_system
+  # @return [String] the operating system the browser is running on
+  alias_native :operating_system, :oscpu
+
+  alias os operating_system
+
+  # @!attribute [r] platform
+  # @return [String] the platform the browser is running on
+  alias_native :platform
+
+  # @!attribute [r] plugins
+  # @return [Native::Array<Plugin>] the enabled plugins
+  def plugins
+    Native::Array.new `#@native.plugins` do |p|
+      Plugin.new(p)
+    end
+  end
+
+  # @!attribute [r] product
+  # @return [Product] the product name and version
+  def product
+    Product.new(`#@native.product`, `#@native.productSub`)
+  end
+
+  # @!attribute [r] user_agent
+  # @return [String] the browser's user agent
+  alias_native :user_agent, :userAgent
+
+  # @!attribute [r] vendor
+  # @return [Vendor] the vendor name and version
+  def vendor
+    Vendor.new(`#@native.vendor`, `#@native.vendorSub`)
+  end
+
+  # Check if Java is enabled.
+  def java?
+    `#@native.javaEnabled()`
+  rescue
+    false
+  end
+end
+
+class Window
+  # Get the {Navigator} object for this window.
+  #
+  # @return [Navigator]
+  def navigator
+    Navigator.new(`#@native.navigator`) if `#@native.navigator`
+  end
+end
+
+end

data/opal/browser/screen.rb

@@ -0,0 +1,40 @@
+module Browser
+
+class Screen
+  include Native
+  include DOM::Event::Target
+
+  target {|value|
+    Screen.new(value) if Native.is_a?(value, `window.Screen`)
+  }
+
+  alias_native :width
+  alias_native :height
+
+  def size
+    Size.new(width, height)
+  end
+
+  alias_native :x, :top
+  alias_native :y, :left
+
+  def position
+    Position.new(x, y)
+  end
+
+  alias_native :color_depth, :colorDepth
+  alias_native :pixel_depth, :pixelDepth
+
+  alias_native :orientation
+end
+
+class Window
+  # Get the {Screen} for this window.
+  #
+  # @return [Screen]
+  def screen
+    Screen.new(`#@native.screen`)
+  end
+end
+
+end

data/opal/browser/socket.rb

@@ -0,0 +1,115 @@
+module Browser
+
+# This class wraps `WebSocket`.
+class Socket
+  def self.supported?
+    defined? `window.WebSocket`
+  end
+
+  include Native
+  include IO::Writable
+  include DOM::Event::Target
+
+  target {|value|
+    Socket.new(value) if Native.is_a?(value, `window.WebSocket`)
+  }
+
+  # Create a connection to the given URL, optionally using the given protocol.
+  #
+  # @param url [String] the URL to connect to
+  # @param protocol [String] the protocol to use
+  # @yield if the block has no parameters it's instance_exec'd, otherwise it's
+  #        called with self
+  def initialize(url, protocol = nil, &block)
+    if native?(url)
+      super(url)
+    elsif protocol
+      super(`new window.WebSocket(#{url.to_s}, #{protocol.to_n})`)
+    else
+      super(`new window.WebSocket(#{url.to_s})`)
+    end
+
+    if block.arity == 0
+      instance_exec(&block)
+    else
+      block.call(self)
+    end if block
+  end
+
+  # @!attribute [r] protocol
+  # @return [String] the protocol of the socket
+  alias_native :protocol
+
+  # @!attribute [r] url
+  # @return [String] the URL the socket is connected to
+  alias_native :url
+
+  # @!attribute [r] buffered
+  # @return [Integer] the amount of buffered data.
+  alias_native :buffered, :bufferedAmount
+
+  # @!attribute [r] type
+  # @return [:blob, :buffer, :string] the type of the socket
+  def type
+    %x{
+      switch (#@native.binaryType) {
+        case "blob":
+          return "blob";
+
+        case "arraybuffer":
+          return "buffer";
+
+        default:
+          return "string";
+      }
+    }
+  end
+
+  # @!attribute [r] state
+  # @return [:connecting, :open, :closing, :closed] the state of the socket
+  def state
+    %x{
+      switch (#@native.readyState) {
+        case window.WebSocket.CONNECTING:
+          return "connecting";
+
+        case window.WebSocket.OPEN:
+          return "open";
+
+        case window.WebSocket.CLOSING:
+          return "closing";
+
+        case window.WebSocket.CLOSED:
+          return "closed";
+      }
+    }
+  end
+
+  # @!attribute [r] extensions
+  # @return [Array<String>] the extensions used by the socket
+  def extensions
+    `#@native.extensions`.split(/\s*,\s*/)
+  end
+
+  # Check if the socket is alive.
+  def alive?
+    state == :open
+  end
+
+  # Send data to the socket.
+  #
+  # @param data [#to_n] the data to send
+  def write(data)
+    `#@native.send(#{data.to_n})`
+  end
+
+  # Close the socket.
+  #
+  # @param code [Integer, nil] the error code
+  # @param reason [String, nil] the reason for closing
+  def close(code = nil, reason = nil)
+    `#@native.close(#{code.to_n}, #{reason.to_n})`
+  end
+end
+
+end