diamonds 0.1.5

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

@@ -0,0 +1,173 @@
+module Browser
+
+# Representation of the navigator application.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/Navigator
+class Navigator
+  include Native
+
+  Version = Struct.new(:major, :minor, :build)
+  Product = Struct.new(:name, :version)
+  Vendor  = Struct.new(:name, :version)
+
+  # Representation of 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
+
+  # Representation of a navigator plugin.
+  #
+  # @see https://developer.mozilla.org/en-US/docs/Web/API/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
+
+  # Representation for the arary of plugins.
+  #
+  # @see https://developer.mozilla.org/en-US/docs/Web/API/NavigatorPlugins
+  class Plugins < Native::Array
+    def initialize(plugins)
+      super plugins do |p|
+        Plugin.new(p)
+      end
+    end
+
+    # Reload all browser plugins.
+    def refresh
+      `#@native.refresh(false)`
+    end
+
+    # Reload all browser plugins reloading pages that contain `<embed>`s.
+    def refresh!
+      `#@native.refresh(true)`
+    end
+  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 [Plugins] the enabled plugins
+  def plugins
+    Plugins.new(`#@native.plugins`)
+  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
+  # @!attribute [r] navigator
+  # @return [Navigator] the navigator
+  def navigator
+    Navigator.new(`#@native.navigator`) if `#@native.navigator`
+  end
+end
+
+end

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

@@ -0,0 +1,66 @@
+module Browser
+
+# Representation of the screen the window is being rendered on.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/Window.screen
+class Screen
+  include Native
+  include Event::Target
+
+  target {|value|
+    Screen.new(value) if Native.is_a?(value, `window.Screen`)
+  }
+
+  Depth = Struct.new(:color, :pixel)
+
+  # @!attribute [r] width
+  # @return [Integer] the width of the screen in pixels
+  alias_native :width
+
+  # @!attribute [r] height
+  # @return [Integer] the height of the screen in pixels
+  alias_native :height
+
+  # @!attribute [r] size
+  # @return [Size] the size in pixels
+  def size
+    Size.new(width, height)
+  end
+
+  # @!attribute [r] x
+  # @return [Integer] the offset from the top left corner of the screen in
+  #                   pixels
+  alias_native :x, :top
+
+  # @!attribute [r] y
+  # @return [Integer] the offset from the top left corner of the screen in
+  #                   pixels
+  alias_native :y, :left
+
+  # @!attribute [r] position
+  # @return [Position] the offset from the top left corner of the screen in
+  #                    pixels
+  def position
+    Position.new(x, y)
+  end
+
+  # @!attribute [r] depth
+  # @return [Depth] the screen depth
+  def depth
+    Depth.new(`#@native.colorDepth`, `#@native.pixelDepth`)
+  end
+
+  # @!attribute [r] orientation
+  # @return [String] the orientation of the screen
+  alias_native :orientation
+end
+
+class Window
+  # @!attribute [r] screen
+  # @return [Screen] the screen for the window
+  def screen
+    Screen.new(`#@native.screen`)
+  end
+end
+
+end

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

@@ -0,0 +1,123 @@
+module Browser
+
+# A {Socket} allows the browser and a server to have a bidirectional data
+# connection.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+class Socket
+  def self.supported?
+    Browser.supports? :WebSocket
+  end
+
+  include Native
+  include IO::Writable
+  include 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
+
+  alias << write
+
+  alias send write
+
+  # 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

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

@@ -0,0 +1,252 @@
+require 'json'
+require 'stringio'
+
+module Browser
+
+# A {Storage} allows you to store data across page loads and browser
+# restarts.
+#
+# Compatibility
+# -------------
+# The compatibility layer will try various implementations in the following
+# order.
+#
+# + [window.localStorage](https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/Storage#localStorage)
+# + [window.globalStorage](https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/Storage#globalStorage)
+# + [document.body.addBehavior](http://msdn.microsoft.com/en-us/library/ms531424(VS.85).aspx)
+# + [document.cookie](https://developer.mozilla.org/en-US/docs/Web/API/document.cookie)
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/Storage
+# @todo remove method_defined? checks when require order is fixed
+class Storage
+  def self.json_create(data)
+    data.delete(JSON.create_id)
+
+    Hash[data.map {|key, value|
+      [JSON.parse(key), value]
+    }]
+  end
+
+  # @!attribute [r] name
+  # @return [String] the name of the storage
+  attr_reader :name
+
+  # Create a new storage on the given window with the given name.
+  #
+  # @param window [native] the window to save the storage to
+  # @param name [String] the name to use to discern different storages
+  def initialize(window, name)
+    super()
+
+    @window = window
+    @name   = name
+    @data   = {}
+
+    autosave!
+    reload
+  end
+
+  # Check if autosaving is enabled.
+  #
+  # When autosaving is enabled the {Storage} is saved every time a change is
+  # made, otherwise you'll have to save it manually yourself.
+  def autosave?
+    @autosave
+  end
+
+  # Enable autosaving.
+  def autosave!
+    @autosave = true
+  end
+
+  # Disable autosaving.
+  def no_autosave!
+    @autosave = false
+  end
+
+  include Enumerable
+
+  # Iterate over the (key, value) pairs in the storage.
+  #
+  # @yield [key, value]
+  def each(&block)
+    return enum_for :each unless block
+
+    @data.each(&block)
+
+    self
+  end
+
+  def method_missing(*args, &block)
+    @data.__send__(*args, &block)
+  end
+
+  # Set a value in the storage.
+  def []=(key, value)
+    @data[key] = value
+
+    save if autosave?
+  end
+
+  # Delete a value from the storage.
+  def delete(key)
+    @data.delete(key).tap {
+      save if autosave?
+    }
+  end
+
+  # Clear the storage.
+  def clear
+    @data.clear.tap {
+      save if autosave?
+    }
+  end
+
+  # Replace the current storage with the given one.
+  #
+  # @param new [Hash, String] if new is a {String} it will be parsed as JSON
+  def replace(new)
+    if String === new
+      @data.replace(JSON.parse(new))
+    else
+      @data.replace(new)
+    end
+  end
+
+  # Call the block between a [#reload] and [#save].
+  def commit(&block)
+    autosave  = @autosave
+    @autosave = false
+    result    = nil
+
+    reload
+
+    begin
+      result = block.call
+      save
+    rescue
+      reload
+      raise
+    ensure
+      @autosave = autosave
+    end
+
+    result
+  end
+
+  def to_h
+    @data
+  end
+
+  # @!method reload
+  #   Load the storage.
+
+  # @!method save
+  #   Persist the current state to the storage.
+
+  if Browser.supports? 'Storage.local'
+    def reload
+      replace `#@window.localStorage[#@name] || '{}'`
+    end
+
+    def save
+      `#@window.localStorage[#@name] = #{JSON.dump(self)}`
+    end
+  elsif Browser.supports? 'Storage.global'
+    def reload
+      replace `#@window.globalStorage[#@window.location.hostname][#@name] || '{}'`
+    end
+
+    def save
+      `#@window.globalStorage[#@window.location.hostname][#@name] = #{JSON.dump(self)}`
+    end
+  elsif Browser.supports? 'Element.addBehavior'
+    def reload
+      %x{
+        #@element = #@window.document.createElement('link');
+        #@element.addBehavior('#default#userData');
+
+        #@window.document.getElementsByTagName('head')[0].appendChild(#@element);
+
+        #@element.load(#@name);
+      }
+
+      replace `#@element.getAttribute(#@name) || '{}'`
+    end
+
+    def save
+      %x{
+        #@element.setAttribute(#@name, #{JSON.dump(self)});
+        #@element.save(#@name);
+      }
+    end
+  else
+    def reload
+      $document.cookies.options expires: 60 * 60 * 24 * 365
+
+      replace $document.cookies[@name]
+    end
+
+    def save
+      $document.cookies[@name] = JSON.dump(self)
+    end
+  end
+
+  # Convert the storage to JSON.
+  #
+  # @return [String] the JSON representation
+  def to_json
+    io = StringIO.new("{")
+
+    io << JSON.create_id.to_json << ":" << self.class.name.to_json << ","
+
+    @data.each {|key, value|
+      io << key.to_json.to_json << ":" << value.to_json << ","
+    }
+
+    io.seek(-1, IO::SEEK_CUR)
+    io << "}"
+
+    io.string
+  end
+end
+
+# A {SessionStorage} allows you to store data across page reloads, as long as the session
+# is active.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/Storage#sessionStorage
+class SessionStorage < Storage
+  def self.supported?
+    Browser.supports? 'Storage.session'
+  end
+
+  def reload
+    replace `#@window.sessionStorage[#@name] || '{}'`
+  end
+
+  def save
+    `#@window.sessionStorage[#@name] = #{JSON.dump(self)}`
+  end
+end
+
+class Window
+  # Get a storage with the given name.
+  #
+  # @param name [Symbol] the name of the storage
+  #
+  # @return [Storage]
+  def storage(name = :default)
+    Storage.new(to_n, name)
+  end
+
+  # Get a session storage with the given name.
+  #
+  # @param name [Symbol] the name of the storage
+  #
+  # @return [SessionStorage]
+  def session_storage(name = :default)
+    SessionStorage.new(to_n, name)
+  end
+end
+
+end