opal-browser 0.2.0.beta1 → 0.3.2

data/opal/browser/window.rb

@@ -1,9 +1,5 @@
-require 'browser/interval'
-require 'browser/delay'
-
 require 'browser/window/view'
 require 'browser/window/size'
-require 'browser/window/scroll'
 
 module Browser
 
@@ -33,7 +29,12 @@ class Window
     }
   end
 
-  include Native
+  include Browser::NativeCachedWrapper
+  include Event::Target
+
+  target {|value|
+    $window if `#{value} == window`
+  }
 
   # Alert the passed string.
   def alert(value)
@@ -43,8 +44,8 @@ class Window
   end
 
   # Display a prompt dialog with the passed string as text.
-  def prompt(value)
-    `#@native.prompt(value) || nil`
+  def prompt(value, default=nil)
+    `#@native.prompt(value, #{default || ""}) || nil`
   end
 
   # Display a confirmation dialog with the passed string as text.
@@ -52,41 +53,61 @@ class Window
     `#@native.confirm(value) || false`
   end
 
+  # @!attribute [r] parent
+  # @return [Window] parent of the current window or subframe
+  def parent
+    @parent ||= Browser::Window.new(`#@native.parent`)
+  end
+
+  # @!attribute [r] top
+  # @return [Window] reference to the topmost window in the window hierarchy
+  def top
+    @top ||= Browser::Window.new(`#@native.top`)
+  end
+
+  # @!attribute [r] opener
+  # @return [Window] reference to the window that opened the window using `open`
+  def opener
+    @opener ||= Browser::Window.new(`#@native.opener`)
+  end
+
   # Get the {View} for the window.
   #
   # @return [View]
   def view
-    View.new(self)
+    @view ||= View.new(self)
   end
 
   # Get the {Size} for this window.
   #
   # @return [Size]
   def size
-    Size.new(self)
+    @size ||= Size.new(self)
   end
 
-  # Get the {Scroll} for this window.
+  # Get the {DOM::Element::Scroll} for this window.
   #
-  # @return [Scroll]
+  # @return [DOM::Element::Scroll]
   def scroll
-    Scroll.new(self)
+    @scroll ||= DOM::Element::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
-    %x{
-      return (window.open('', '_self', '') && window.close()) ||
-             (window.opener = null && window.close()) ||
-             (window.opener = '' && window.close());
-    }
+    `#{@native}.close()`
   end
 end
 
@@ -101,8 +122,8 @@ module Kernel
   end
 
   # (see Browser::Window#prompt)
-  def prompt(value)
-    $window.prompt(value)
+  def prompt(value, default=nil)
+    $window.prompt(value, default)
   end
 
   # (see Browser::Window#confirm)

data/opal/browser.rb

@@ -1,10 +1 @@
-require 'native'
-require 'paggio'
-
-require 'browser/version'
-require 'browser/utils'
-require 'browser/support'
-
-require 'browser/window'
-require 'browser/dom'
-require 'browser/css'
+require 'browser/setup/traditional'

data/opal/opal-browser.rb

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

data/opal-browser.gemspec

@@ -4,7 +4,7 @@ require 'browser/version'
 Gem::Specification.new {|s|
   s.name     = 'opal-browser'
   s.version  = Browser::VERSION
-  s.author   = 'meh.'
+  s.author   = ['meh.', 'hmdne']
   s.email    = 'meh@schizofreni.co'
   s.homepage = 'http://github.com/opal/opal-browser'
   s.platform = Gem::Platform::RUBY
@@ -16,6 +16,6 @@ Gem::Specification.new {|s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths = ['lib']
 
-  s.add_dependency 'opal', '~> 0.6.0'
-  s.add_dependency 'paggio'
+  s.add_dependency 'opal', ['>= 1.0', '< 2.0']
+  s.add_dependency 'paggio', '>= 0.3.0'
 }

data/spec/database/sql_spec.rb

@@ -0,0 +1,139 @@
+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
+    it 'calls the block with the transaction' do
+      sql = SQL.new('test', size: SIZE)
+
+      promise = Browser::Promise.new
+      sql.transaction {|t|
+        expect(t).to be_a(SQL::Transaction)
+        promise.resolve
+      }
+      promise.for_rspec
+    end
+
+    it 'the transaction database is the right one' do
+      sql = SQL.new('test', size: SIZE)
+
+      promise = Browser::Promise.new
+      sql.transaction {|t|
+        expect(t.database).to eq(sql)
+        promise.resolve
+      }
+      promise.for_rspec
+    end
+  end
+
+  describe SQL::Transaction do
+    describe '#query' do
+      it 'returns a promise' do
+        sql = SQL.new('test', size: SIZE)
+
+        promise = Browser::Promise.new
+        sql.transaction {|t|
+          expect(t.query('hue')).to be_a(Promise)
+          promise.resolve
+        }
+        promise.for_rspec
+      end
+
+      it 'resolves on success' do
+        sql = SQL.new('test', size: SIZE)
+
+        promise = Browser::Promise.new
+        sql.transaction {|t|
+          t.query('CREATE TABLE IF NOT EXISTS test(ID INTEGER PRIMARY KEY ASC, a TEXT)').then {|r|
+            expect(r).to be_a(SQL::Result)
+            promise.resolve
+          }
+        }
+        promise.for_rspec
+      end
+
+      it 'rejects on failure' do
+        sql = SQL.new('test', size: SIZE)
+
+        promise = Browser::Promise.new
+        sql.transaction {|t|
+          t.query('huehue').rescue {|e|
+            expect(e).to be_a(SQL::Error::Syntax)
+            promise.resolve
+          }
+        }
+        promise.for_rspec
+      end
+    end
+  end
+
+  describe SQL::Result do
+    describe '#length' do
+      it 'has the proper length' do
+        sql = SQL.new('test', size: SIZE)
+
+        promise = Browser::Promise.new
+        sql.transaction {|t|
+          t.query('SELECT 1').then {|r|
+            expect(r.length).to eq(1)
+            promise.resolve
+          }
+        }
+        promise.for_rspec
+      end
+    end
+
+    describe '#[]' do
+      it 'returns a row' do
+        sql = SQL.new('test', size: SIZE)
+
+        promise = Browser::Promise.new
+        sql.transaction {|t|
+          t.query('SELECT 1, 2, 3').then {|r|
+            expect(r[0]).to be_a(SQL::Row)
+            expect(r[-1]).to be_a(SQL::Row)
+
+            expect(r[0]).to eq(r[-1])
+            promise.resolve
+          }
+        }
+        promise.for_rspec
+      end
+
+      it 'returns nil on missing row' do
+        sql = SQL.new('test', size: SIZE)
+
+        promise = Browser::Promise.new
+        sql.transaction {|t|
+          t.query('SELECT 1, 2, 3').then {|r|
+            expect(r[5]).to be_nil
+            expect(r[-5]).to be_nil
+            promise.resolve
+          }
+        }
+        promise.for_rspec
+      end
+    end
+  end
+end if Browser::Database::SQL.supported?

data/spec/delay_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'browser/delay'
+
+describe Browser::Window do
+  describe '#after' do
+    it 'calls the block after the given time' do
+      promise = Browser::Promise.new
+      $window.after 0.3 do
+        expect(true).to be_truthy
+        promise.resolve
+      end
+      promise.for_rspec
+    end
+  end
+end
+
+describe Kernel do
+  describe '#after' do
+    it 'calls the block after the given time' do
+      promise = Browser::Promise.new
+      after 0.3 do
+        expect(true).to be_truthy
+        promise.resolve
+      end
+      promise.for_rspec
+    end
+  end
+end
+
+describe Proc do
+  describe '#after' do
+    it 'calls the block after the given time' do
+      promise = Browser::Promise.new
+      -> {
+        expect(true).to be_truthy
+        promise.resolve
+      }.after 0.3
+      promise.for_rspec
+    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,26 @@ describe Browser::DOM::Document do
       expect($document["doo-dah"]).to be_nil
     end
   end
+
+  describe "#ready" do
+    it "calls the block when the document is ready" do
+      promise = Browser::Promise.new
+      $document.ready do
+        expect(true).to be_truthy
+        promise.resolve
+      end
+      promise.for_rspec
+    end
+  end
+
+  describe "#ready?" do
+    it "is true inside a #ready block" do
+      promise = Browser::Promise.new
+      $document.ready do
+        expect($document.ready?).to be_truthy
+        promise.resolve
+      end
+      promise.for_rspec
+    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

data/spec/dom/element/custom_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'browser/dom/element/custom'
+
+describe Browser::DOM::Element::Custom do
+  before(:each) do
+    $scratchpad = Hash.new { false }
+  end
+
+  def create_custom_class(name, observed_attrs = [])
+    Class.new(Browser::DOM::Element::Custom) do
+      def initialize(node)
+        super
+        $scratchpad[:initialized] = true
+      end
+
+      def attached
+        $scratchpad[:attached] = true
+      end
+
+      def detached
+        $scratchpad[:detached] = true
+      end
+
+      def adopted
+        $scratchpad[:adopted] = true
+      end
+
+      def attribute_changed(attr, from, to)
+        $scratchpad[:attribute_changed] = [attr, from, to]
+      end
+
+      self.observed_attributes = observed_attrs
+
+      def_custom name
+    end
+  end
+
+  describe "upgrades" do
+    html <<-HTML
+      <app-ex1></app-ex1>
+      <app-ex2></app-ex2>
+      <app-ex7 prop="true"></app-ex7>
+    HTML
+
+    it "existing elements when they have been initialized before" do
+      expect($document.at_css("app-ex1").class).to eq(Browser::DOM::Element)
+      klass = create_custom_class("app-ex1")
+      expect($document.at_css("app-ex1").class).to eq(klass)
+      expect($scratchpad[:initialized]).to be(true)
+      expect($scratchpad[:attached]).to be(true)
+    end
+
+    it "existing elements when they have not been initialized before" do
+      klass = create_custom_class("app-ex2")
+      expect($scratchpad[:initialized]).to be(true)
+      expect($scratchpad[:attached]).to be(true)
+      expect($document.at_css("app-ex2").class).to eq(klass)
+    end
+
+    it "and fires property update events when upgraded" do
+      klass = create_custom_class("app-ex7", ["prop"])
+      expect($scratchpad[:attribute_changed]).to eq([:prop, nil, "true"])
+    end
+  end
+
+  it "creates and handles new elements correctly" do
+    klass = create_custom_class("app-ex3")
+    elem = klass.new
+    expect($scratchpad[:initialized]).to be(true)
+    expect($scratchpad[:attached]).to be(false)
+    $document.body << elem
+    expect($scratchpad[:detached]).to be(false)
+    expect($scratchpad[:attached]).to be(true)
+    elem.remove
+    expect($scratchpad[:detached]).to be(true)
+  end
+
+  it "correctly tracks updated properties" do
+    klass = create_custom_class("app-ex4")
+    elem = klass.new
+    expect($scratchpad[:attribute_changed]).to be(false)
+    elem[:untracked] = "test"
+    expect($scratchpad[:attribute_changed]).to be(false)
+
+    klass = create_custom_class("app-ex5", ["tracked"])
+    elem = klass.new
+    expect($scratchpad[:attribute_changed]).to be(false)
+    elem[:untracked] = "test"
+    expect($scratchpad[:attribute_changed]).to be(false)
+    elem[:tracked] = "test"
+    expect($scratchpad[:attribute_changed]).to eq([:tracked, nil, "test"])
+  end
+
+  it "allows creation of custom elements in various ways" do
+    klass = create_custom_class("app-ex6")
+
+    elem = klass.new
+    expect(elem).to be_a(klass)
+    elem = $document.create_element("app-ex6")
+    expect(elem).to be_a(klass)
+    elem = DOM("<app-ex6>")
+    expect(elem).to be_a(klass)
+    elem = DOM { e("app-ex6") }
+    expect(elem).to be_a(klass)
+  end
+end