opal-browser 0.1.0.beta1

data/opal/browser/storage.rb

@@ -0,0 +1,149 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'json'
+require 'stringio'
+
+module Browser
+
+class Storage < Hash
+  def self.json_create(data)
+    data.delete(JSON.create_id)
+
+    Hash[data.map {|key, value|
+      [JSON.parse(key), value]
+    }]
+  end
+
+  attr_reader :name
+
+  def initialize(window, name)
+    super()
+
+    @window = window
+    @name   = name
+
+    autosave!
+
+    init if respond_to? :init
+  end
+
+  def encoded_name
+    "$opal.storage.#{@name}"
+  end
+
+  def autosave?;    @autosave;         end
+  def autosave!;    @autosave = true;  end
+  def no_autosave!; @autosave = false; end
+
+  def replace(what)
+    if what.is_a?(String)
+      super JSON.parse(what)
+    else
+      super
+    end
+  end
+
+  %w([]= delete clear).each {|name|
+    define_method name do |*args|
+      # FIXME: remove the application when it's fixed
+      super(*args).tap {
+        save if autosave?
+      }
+    end
+  }
+
+  def save; end
+
+  if `window.localStorage`
+    def init
+      replace `#@window.localStorage[#{encoded_name}] || '{}'`
+    end
+
+    def save
+      `#@window.localStorage[#{encoded_name}] = #{JSON.dump(self)}`
+    end
+  elsif `window.globalStorage`
+    def init
+      replace `#@window.globalStorage[#@window.location.hostname][#{encoded_name}] || '{}'`
+    end
+
+    def save
+      `#@window.globalStorage[#@window.location.hostname][#{encoded_name}] = #{JSON.dump(self)}`
+    end
+  elsif `document.body.addBehavior`
+    def init
+      %x{
+        #@element = #@window.document.createElement('link');
+        #@element.addBehavior('#default#userData');
+
+        #@window.document.getElementsByTagName('head')[0].appendChild(#@element);
+
+        #@element.load(#{encoded_name});
+      }
+
+      replace `#@element.getAttribute(#{encoded_name}) || '{}'`
+    end
+
+    def save
+      %x{
+        #@element.setAttribute(#{encoded_name}, #{JSON.dump(self)});
+        #@element.save(#{encoded_name});
+      }
+    end
+  else
+    def init
+      $document.cookies.options expires: 60 * 60 * 24 * 365
+
+      replace $document.cookies[encoded_name]
+    end
+
+    def save
+      $document.cookies[encoded_name] = self
+    end
+  end
+
+  def to_json
+    io = StringIO.new("{")
+
+    io << JSON.create_id.to_json << ":" << self.class.name.to_json << ","
+
+    each {|key, value|
+      io << key.to_json.to_json << ":" << value.to_json << ","
+    }
+
+    io.seek(-1, IO::SEEK_CUR)
+    io << "}"
+
+    io.string
+  end
+end
+
+class SessionStorage < Storage
+  def init
+    replace `#@window.sessionStorage[#{encoded_name}] || '{}'`
+  end
+
+  def save
+    `#@window.sessionStorage[#{encoded_name}] = #{JSON.dump(self)}`
+  end
+end
+
+class Window
+  def storage(name = :default)
+    Storage.new(to_n, name)
+  end
+
+  def session_storage(name = :default)
+    SessionStorage.new(to_n, name)
+  end
+end
+
+end

data/opal/browser/timeout.rb

@@ -0,0 +1,60 @@
+module Browser
+
+# This class wraps `setTimeout`.
+class Timeout
+  # @!attribute [r] after
+  # @return [Number] the seconds after which the block is called
+  attr_reader :after
+
+  # Create and start a timeout.
+  #
+  # @param window [Window] the window to start the timeout on
+  # @param time [Number] seconds after which the block is called
+  def initialize(window, time, &block)
+    @window = Native.convert(window)
+    @after  = time
+    @block  = block
+
+    start
+  end
+
+  # Abort the timeout.
+  #
+  # @return [self]
+  def abort
+    `#@window.clearTimeout(#@id)`
+
+    self
+  end
+
+  def start
+    @id = `#@window.setTimeout(#{@block.to_n}, #@after * 1000)`
+
+    self
+  end
+end
+
+class Window
+  # Execute a block after the given seconds.
+  #
+  # @param time [Float] the seconds after it gets called
+  # @return [Timeout] the object representing the timeout
+  def after(time, &block)
+    Timeout.new(@native, time, &block)
+  end
+end
+
+end
+
+class Proc
+  def after(time)
+    $window.after(time, &self)
+  end
+end
+
+module Kernel
+  # (see Browser::Window#once)
+  def after(time, &block)
+    $window.after(time, &block)
+  end
+end

data/opal/browser/utils.rb

@@ -0,0 +1,56 @@
+module Browser
+  Size     = Struct.new(:width, :height)
+  Position = Struct.new(:x, :y)
+end
+
+class String
+  # Encode as URI component.
+  #
+  # @return [String] the string encoded for usage as URI component
+  def encode_uri_component
+    `encodeURIComponent(self)`
+  end
+
+  # Encode as URI.
+  #
+  # @return [String] the string encoded as URI
+  def encode_uri
+    `encodeURI(self)`
+  end
+
+  # Decode as URI component.
+  #
+  # @return [String] the string decoded as URI component
+  def decode_uri_component
+    `decodeURIComponent(self)`
+  end
+
+  # Decode as URI.
+  #
+  # @return [String] the string decoded as URI
+  def decode_uri
+    `decodeURI(self)`
+  end
+end
+
+class Hash
+  def self.decode_uri(string)
+    self[string.split(?&).map {|part|
+      name, value = part.split(?=)
+
+      [name.decode_uri_component, value.decode_uri_component]
+    }]
+  end
+
+  def encode_uri
+    map {|name, value|
+      "#{name.to_s.encode_uri_component}=#{value.to_s.encode_uri_component}"
+    }.join(?&)
+  end
+end
+
+class Object
+  def encode_uri
+    to_s.encode_uri
+  end
+end

data/opal/browser/version.rb

@@ -0,0 +1,3 @@
+module Browser
+  VERSION = '0.1.0.beta1'
+end

data/opal/browser/window.rb

@@ -0,0 +1,113 @@
+require 'browser/interval'
+require 'browser/timeout'
+
+require 'browser/window/view'
+require 'browser/window/size'
+require 'browser/window/scroll'
+require 'browser/window/compatibility'
+
+module Browser
+
+# Wrapper class for the `window` object, an instance of it gets
+# set to `$window`.
+class Window
+  def self.open(url, options)
+    name     = options.delete(:name)
+    features = options.map {|key, value|
+      value = case value
+              when true  then :yes
+              when false then :no
+              else            value
+              end
+
+      "#{key}=#{value}"
+    }.join(?,)
+
+    %x{
+      var win = window.open(#{url}, #{name}, #{features});
+
+      if (win == null) {
+        return nil;
+      }
+
+      return #{new(`win`)};
+    }
+  end
+
+  include Native
+
+  # Alert the passed string.
+  def alert(value)
+    `#@native.alert(value)`
+
+    value
+  end
+
+  # Display a prompt dialog with the passed string as text.
+  def prompt(value)
+    `#@native.prompt(value) || nil`
+  end
+
+  # Display a confirmation dialog with the passed string as text.
+  def confirm(value)
+    `#@native.confirm(value) || false`
+  end
+
+  # Get the {View} for the window.
+  #
+  # @return [View]
+  def view
+    View.new(self)
+  end
+
+  # Get the {Size} for this window.
+  #
+  # @return [Size]
+  def size
+    Size.new(self)
+  end
+
+  # Get the {Scroll} for this window.
+  #
+  # @return [Scroll]
+  def scroll
+    Scroll.new(self)
+  end
+
+  # Send a message to the window.
+  #
+  # @param message [String] the message
+  # @param options [Hash] optional `to: target`
+  def send!(message, options = {})
+    `#@native.postMessage(#{message}, #{options[:to] || '*'})`
+  end
+
+  def close
+    %x{
+      return (window.open('', '_self', '') && window.close()) ||
+             (window.opener = null && window.close()) ||
+             (window.opener = '' && window.close());
+    }
+  end
+end
+
+end
+
+$window = Browser::Window.new(`window`)
+
+module Kernel
+  # (see Browser::Window#alert)
+  def alert(value)
+    $window.alert(value)
+  end
+
+  # (see Browser::Window#prompt)
+  def prompt(value)
+    $window.prompt(value)
+  end
+
+  # (see Browser::Window#confirm)
+  def confirm(value)
+    $window.confirm(value)
+  end
+end

data/opal/browser/window/compatibility.rb

@@ -0,0 +1,3 @@
+require 'browser/compatibility/window/view'
+require 'browser/compatibility/window/size'
+require 'browser/compatibility/window/scroll'

data/opal/browser/window/scroll.rb

@@ -0,0 +1,49 @@
+module Browser; class Window
+
+class Scroll
+  def initialize(window)
+    @window = window
+    @native = window.to_n
+  end
+
+  def position
+    %x{
+      var doc  = #@native.document,
+          root = doc.documentElement,
+          body = doc.body;
+
+      var x = root.scrollLeft || body.scrollLeft,
+          y = root.scrollTop  || body.scrollTop;
+    }
+
+    Position.new(`x`, `y`)
+  end
+
+  def x
+    position.x
+  end
+
+  def y
+    position.y
+  end
+
+  def to(what)
+    x   = what[:x] || self.x
+    y   = what[:y] || self.y
+
+    `#@native.scrollTo(#{x}, #{y})`
+
+    self
+  end
+
+  def by(what)
+    x = what[:x] || 0
+    y = what[:y] || 0
+
+    `#@native.scrollBy(#{x}, #{y})`
+
+    self
+  end
+end
+
+end; end

data/opal/browser/window/size.rb

@@ -0,0 +1,35 @@
+module Browser; class Window
+
+class Size
+  def initialize(window)
+    @window = window
+    @native = window.to_n
+  end
+
+  def set(what)
+    width  = what[:width]  || self.width
+    height = what[:height] || self.height
+
+    `#@native.resizeTo(#{width}, #{height})`
+
+    self
+  end
+
+  def width
+    `#@native.outerWidth`
+  end
+
+  def width=(value)
+    set(width: value)
+  end
+
+  def height
+    `#@native.outerHeight`
+  end
+
+  def height=(value)
+    set(height: value)
+  end
+end
+
+end; end