opal-browser 0.2.0.beta1 → 0.2.0

data/opal/browser/version.rb

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

data/opal/browser/window.rb

@@ -1,6 +1,3 @@
-require 'browser/interval'
-require 'browser/delay'
-
 require 'browser/window/view'
 require 'browser/window/size'
 require 'browser/window/scroll'
@@ -34,6 +31,11 @@ class Window
   end
 
   include Native
+  include Event::Target
+
+  target {|value|
+    $window if `#{value} == window`
+  }
 
   # Alert the passed string.
   def alert(value)
@@ -73,12 +75,18 @@ class Window
     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] || '*'})`
+  if Browser.supports? 'Window.send'
+    def send(message, options = {})
+      `#@native.postMessage(#{message}, #{options[:to] || '*'})`
+    end
+  else
+    # Send a message to the window.
+    #
+    # @param message [String] the message
+    # @param options [Hash] optional `to: target`
+    def send(message, options = {})
+      raise NotImplementedError, 'message sending unsupported'
+    end
   end
 
   def close

data/opal/browser/window/size.rb

@@ -1,20 +1,34 @@
 module Browser; class Window
 
+# Allows access and manipulation of the {Window} size.
 class Size
+  # @private
   def initialize(window)
     @window = window
     @native = window.to_n
   end
 
-  def set(what)
-    width  = what[:width]  || self.width
-    height = what[:height] || self.height
+  def set(*args)
+    if Hash === args.first
+      width, height = args.first.values_at(:width, :height)
+    else
+      width, height = args
+    end
+
+    width  ||= self.width
+    height ||= self.height
 
     `#@native.resizeTo(#{width}, #{height})`
 
     self
   end
 
+  # @!attribute width
+  # @return [Integer] the width of the window
+
+  # @!attribute height
+  # @return [Integer] the height of the window
+
   if Browser.supports? 'Window.outerSize'
     def width
       `#@native.outerWidth`

data/opal/opal-browser.rb

@@ -0,0 +1 @@
+require 'browser'

data/spec/database/sql_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require 'browser/database/sql'
+
+describe Browser::Database::SQL do
+  SQL  = Browser::Database::SQL
+  SIZE = 1024 * 1024
+
+  describe '#new' do
+    it 'sets the attributes properly' do
+      sql = SQL.new('test', description: 'trains', size: SIZE)
+
+      expect(sql.name).to eq('test')
+      expect(sql.description).to eq('trains')
+      expect(sql.size).to eq(SIZE)
+    end
+
+    it 'sets the version properly' do
+      sql = SQL.new('test2', version: '1.0', size: SIZE)
+      expect(sql.version).to eq('1.0')
+
+      sql = SQL.new('test', size: SIZE)
+      expect(sql.version).to eq('')
+    end
+  end
+
+  describe '#transaction' do
+    async 'calls the block with the transaction' do
+      sql = SQL.new('test', size: SIZE)
+
+      sql.transaction {|t|
+        async {
+          expect(t).to be_a(SQL::Transaction)
+        }
+      }
+    end
+
+    async 'the transaction database is the right one' do
+      sql = SQL.new('test', size: SIZE)
+
+      sql.transaction {|t|
+        async {
+          expect(t.database).to eq(sql)
+        }
+      }
+    end
+  end
+
+  describe SQL::Transaction do
+    describe '#query' do
+      async 'returns a promise' do
+        sql = SQL.new('test', size: SIZE)
+
+        sql.transaction {|t|
+          async {
+            expect(t.query('hue')).to be_a(Promise)
+          }
+        }
+      end
+
+      async 'resolves on success' do
+        sql = SQL.new('test', size: SIZE)
+
+        sql.transaction {|t|
+          t.query('CREATE TABLE IF NOT EXISTS test(ID INTEGER PRIMARY KEY ASC, a TEXT)').then {|r|
+            async {
+              expect(r).to be_a(SQL::Result)
+            }
+          }
+        }
+      end
+
+      async 'rejects on failure' do
+        sql = SQL.new('test', size: SIZE)
+
+        sql.transaction {|t|
+          t.query('huehue').rescue {|e|
+            async {
+              expect(e).to be_a(SQL::Error::Syntax)
+            }
+          }
+        }
+      end
+    end
+  end
+
+  describe SQL::Result do
+    describe '#length' do
+      async 'has the proper length' do
+        sql = SQL.new('test', size: SIZE)
+
+        sql.transaction {|t|
+          t.query('SELECT 1').then {|r|
+            async {
+              expect(r.length).to eq(1)
+            }
+          }
+        }
+      end
+    end
+
+    describe '#[]' do
+      async 'returns a row' do
+        sql = SQL.new('test', size: SIZE)
+
+        sql.transaction {|t|
+          t.query('SELECT 1, 2, 3').then {|r|
+            async {
+              expect(r[0]).to be_a(SQL::Row)
+              expect(r[-1]).to be_a(SQL::Row)
+
+              expect(r[0]).to eq(r[-1])
+            }
+          }
+        }
+      end
+
+      async 'returns nil on missing row' do
+        sql = SQL.new('test', size: SIZE)
+
+        sql.transaction {|t|
+          t.query('SELECT 1, 2, 3').then {|r|
+            async {
+              expect(r[5]).to be_nil
+              expect(r[-5]).to be_nil
+            }
+          }
+        }
+      end
+    end
+  end
+end if Browser::Database::SQL.supported?

data/spec/delay_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'browser/delay'
+
+describe Browser::Window do
+  describe '#after' do
+    async 'calls the block after the given time' do
+      $window.after 0.3 do
+        async {
+          expect(true).to be_truthy
+        }
+      end
+    end
+  end
+end
+
+describe Kernel do
+  describe '#after' do
+    async 'calls the block after the given time' do
+      after 0.3 do
+        async {
+          expect(true).to be_truthy
+        }
+      end
+    end
+  end
+end
+
+describe Proc do
+  describe '#after' do
+    async 'calls the block after the given time' do
+      -> {
+        async {
+          expect(true).to be_truthy
+        }
+      }.after 0.3
+    end
+  end
+end

data/spec/dom/attribute_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Browser::DOM::Attribute do
+  html <<-HTML
+    <div id="lol" class="hue" something="wat"></div>
+  HTML
+
+  describe '#name' do
+    it 'gets the right name' do
+      attr = $document['lol'].attribute_nodes.find { |a| a.name == :id }
+
+      expect(attr.name).to eq(:id)
+    end
+  end
+
+  describe '#value' do
+    it 'gets the right value' do
+      attr = $document['lol'].attribute_nodes.find { |a| a.name == :id }
+
+      expect(attr.name).to eq(:id)
+      expect(attr.value).to eq(:lol)
+    end
+  end
+
+  describe '#value=' do
+    it 'sets the value' do
+      attr = $document['lol'].attribute_nodes.find { |a| a.name == :id }
+
+      expect(attr.name).to eq(:id)
+      expect(attr.value).to eq(:lol)
+      attr.value = :omg
+      expect(attr.value).to eq(:omg)
+    end
+  end
+
+  describe '#id?' do
+    it 'is true for an id attribute' do
+      attr = $document['lol'].attribute_nodes.find { |a| a.name == :id }
+
+      expect(attr.id?).to be_truthy
+    end
+
+    it 'is false for any other attribute' do
+      attr = $document['lol'].attribute_nodes.find { |a| a.name == :class }
+
+      expect(attr.id?).to be_falsy
+    end
+  end
+end

data/spec/dom/builder_spec.rb

@@ -2,27 +2,35 @@ require 'spec_helper'
 
 describe Browser::DOM::Builder do
   it 'builds an element' do
-    expect(DOM {
+    res = DOM {
       div
-    }.name).to eq('DIV')
+    }
+
+    expect(res.name).to eq('DIV')
   end
 
   it 'builds an element with text content' do
-    expect(DOM {
+    res = DOM {
       div "foo bar"
-    }.text).to eq('foo bar')
+    }
 
-    expect(DOM {
+    expect(res.text).to eq('foo bar')
+
+    res = DOM {
       div {
         "foo bar"
       }
-    }.text).to eq('foo bar')
+    }
+
+    expect(res.text).to eq('foo bar')
   end
 
   it 'builds an element with attributes' do
-    expect(DOM {
+    res = DOM {
       div class: :wut
-    }.class_name).to eq(:wut)
+    }
+
+    expect(res.class_name).to eq(:wut)
   end
 
   it 'builds deeper trees' do
@@ -66,4 +74,13 @@ describe Browser::DOM::Builder do
     expect(res.name).to eq('I')
     expect(res.class_names).to eq(%w[icon-legal])
   end
+
+  it 'sets the id' do
+    res = DOM {
+      div.omg!
+    }
+
+    expect(res.name).to eq('DIV')
+    expect(res.id).to eq('omg')
+  end
 end

data/spec/dom/document_spec.rb

@@ -37,4 +37,24 @@ describe Browser::DOM::Document do
       expect($document["doo-dah"]).to be_nil
     end
   end
+
+  describe "#ready" do
+    async "calls the block when the document is ready" do
+      $document.ready do
+        async {
+          expect(true).to be_truthy
+        }
+      end
+    end
+  end
+
+  describe "#ready?" do
+    async "is true inside a #ready block" do
+      $document.ready do
+        async {
+          expect($document.ready?).to be_truthy
+        }
+      end
+    end
+  end
 end

data/spec/dom/element/attributes_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Browser::DOM::Element::Attributes do
+  html <<-HTML
+    <label id="lol" class="name" for="hue"></label>
+  HTML
+
+  describe '#[]' do
+    it 'gets an attribute' do
+      expect($document[:lol].attributes[:id]).to eq(:lol)
+    end
+
+    it 'gets the class attribute' do
+      expect($document[:lol].attributes[:class]).to eq(:name)
+    end
+
+    it 'gets the for attribute' do
+      expect($document[:lol].attributes[:for]).to eq(:hue)
+    end
+  end
+
+  describe '#[]=' do
+    it 'sets an attribute' do
+      $document[:lol].attributes[:a] = :foo
+
+      expect($document[:lol].attributes[:a]).to eq(:foo)
+    end
+
+    it 'sets the class attribute' do
+      $document[:lol].attributes[:class] = :bar
+
+      expect($document[:lol].attributes[:class]).to eq(:bar)
+    end
+
+    it 'sets the for attribute' do
+      $document[:lol].attributes[:for] = :baz
+
+      expect($document[:lol].attributes[:for]).to eq(:baz)
+    end
+  end
+
+  describe '#each' do
+    it 'enumerates over the attributes' do
+      attributes = $document[:lol].attributes.select {|name, _|
+        %w[class for id].include?(name)
+      }
+
+      expect(attributes.sort).to eq \
+        [[:class, :name], [:for, :hue], [:id, :lol]]
+    end
+  end
+end