opal-browser 0.1.0.beta1 → 0.3.1

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
-    DOM {
+    res = DOM {
       div
-    }.name.should == 'DIV'
+    }
+
+    expect(res.name).to eq('DIV')
   end
 
   it 'builds an element with text content' do
-    DOM {
+    res = DOM {
       div "foo bar"
-    }.text.should == "foo bar"
+    }
 
-    DOM {
+    expect(res.text).to eq('foo bar')
+
+    res = DOM {
       div {
         "foo bar"
       }
-    }.text.should == "foo bar"
+    }
+
+    expect(res.text).to eq('foo bar')
   end
 
   it 'builds an element with attributes' do
-    DOM {
+    res = DOM {
       div class: :wut
-    }.class_name.should == :wut
+    }
+
+    expect(res.class_name).to eq(:wut)
   end
 
   it 'builds deeper trees' do
@@ -34,15 +42,15 @@ describe Browser::DOM::Builder do
       }
     }
 
-    res.name.should == 'DIV'
-    res.child.name.should == 'SPAN'
-    res.child.text.should == 'wut'
+    expect(res.name).to eq('DIV')
+    expect(res.child.name).to eq('SPAN')
+    expect(res.child.text).to eq('wut')
   end
 
   it 'sets classes with methods' do
-    DOM {
+    expect(DOM {
       div.nice.element
-    }.class_names.should == %w[nice element]
+    }.class_names).to eq(%w[nice element])
   end
 
   it 'nests when setting classes' do
@@ -52,10 +60,10 @@ describe Browser::DOM::Builder do
       }
     }
 
-    res.name.should == 'DIV'
-    res.class_names.should == %w[nice element]
-    res.child.name.should == 'SPAN'
-    res.child.class_names.should == %w[nicer]
+    expect(res.name).to eq('DIV')
+    expect(res.class_names).to eq(%w[nice element])
+    expect(res.child.name).to eq('SPAN')
+    expect(res.child.class_names).to eq(%w[nicer])
   end
 
   it 'joins class name properly' do
@@ -63,7 +71,16 @@ describe Browser::DOM::Builder do
       i.icon[:legal]
     }
 
-    res.name.should == 'I'
-    res.class_names.should == %w[icon-legal]
+    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

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Browser::DOM::Document do
   describe '#title' do
     it 'should get the document title' do
-      $document.title.should be_kind_of(String)
+      expect($document.title).to be_a(String)
     end
   end
 
@@ -11,7 +11,7 @@ describe Browser::DOM::Document do
     it 'should set the document title' do
       old = $document.title
       $document.title = 'lol'
-      $document.title.should == 'lol'
+      expect($document.title).to eq('lol')
       $document.title = old
     end
   end
@@ -22,19 +22,41 @@ describe Browser::DOM::Document do
     HTML
 
     it "should get element by id" do
-      $document["lol"].should == `#{$document.to_n}.getElementById('lol')`
+      expect($document["lol"]).to eq(`document.getElementById('lol')`)
     end
 
     it "should get element by css" do
-      $document["lol"].should == `#{$document.to_n}.getElementById('lol')`
+      expect($document["#lol"]).to eq(`document.getElementById('lol')`)
     end
 
     it "should get element by xpath" do
-      $document["//*[@id='lol']"].should == `#{$document.to_n}.getElementById('lol')`
+      expect($document["//*[@id='lol']"]).to eq(`document.getElementById('lol')`)
     end
 
     it "should return nil if it can't find anything" do
-      $document["doo-dah"].should be_nil
+      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

data/spec/dom/element/subclass_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe "Browser::DOM::Element subclassing" do
+  class1 = Class.new(Browser::DOM::Element) do
+    def_selector ".class1"
+
+    def hello
+      "world"
+    end
+  end
+
+  class2 = Class.new(Browser::DOM::Element::Input) do
+    def_selector "input.class2[type='text']"
+
+    def hello
+      "goodbye"
+    end
+  end
+
+  class3 = Class.new(class2) do
+    def_selector "input.class2.class3[type='text']"
+
+    def self.create(value)
+      super().tap { |elem| elem.value = value }
+    end
+  end
+
+  class4 = Class.new(Browser::DOM::Element) do
+    def_selector "custom-element"
+
+    def hello
+      text
+    end
+  end
+
+  html <<-HTML
+    <div class='class1' id='hiho'></div>
+    <input class='class2' type='text' id='hoho'></div>
+    <input class='class2' type='hidden' id='hehe'></div>
+    <custom-element id='class4'>value</custom-element>
+  HTML
+
+  it 'dispatches from DOM correctly' do
+    elem = $document.at_css('#hiho')
+    expect(elem.class).to eq(class1)
+    expect(elem.hello).to eq('world')
+
+    elem = $document.at_css('#hoho')
+    expect(elem.class).to eq(class2)
+    expect(elem.hello).to eq('goodbye')
+
+    elem = $document.at_css('#hehe')
+    expect(elem.class).to eq(Browser::DOM::Element::Input)
+  end
+
+  it 'supports creating elements correctly' do
+    elem = class1.create
+    expect(elem.class).to eq(class1)
+    expect(elem.class_name).to eq('class1')
+    expect(elem.name).to eq('DIV')
+    expect(elem.hello).to eq('world')
+
+    elem = class2.create
+    expect(elem.class).to eq(class2)
+    expect(elem.class_name).to eq('class2')
+    expect(elem.name).to eq('INPUT')
+    expect(elem.hello).to eq('goodbye')
+    expect(elem.type).to eq('text')
+  end
+
+  it 'supports nested subclassing and .create overloading' do
+    elem = class3.create('well')
+    expect(elem.class).to eq(class3)
+    expect(elem.class_name).to eq('class2 class3')
+    expect(elem.value).to eq('well')
+    expect(elem.hello).to eq('goodbye')
+  end
+
+  it 'supports custom elements' do
+    elem = $document.at_css('#class4')
+    expect(elem.class).to eq(class4)
+    expect(elem.name).to eq('CUSTOM-ELEMENT')
+    expect(elem.hello).to eq('value')
+
+    elem = class4.create
+    expect(elem.class).to eq(class4)
+    expect(elem.name).to eq('CUSTOM-ELEMENT')
+    expect(elem.hello).to eq('')
+  end
+
+  it 'works with Paggio' do
+    elem = DOM { div.class1 }
+    expect(elem.class).to eq(class1)
+    expect(elem.hello).to eq('world')
+  end
+
+  it 'works with Paggio with a .create/.new intializer' do
+    elems = DOM {
+      class1.create(self)
+      class1.new(self, attrs: { x: :y })
+      class1.new(self)
+    }
+    expect(elems.class).to eq(Browser::DOM::NodeSet)
+    expect(elems.length).to eq(3)
+    expect(elems[1][:x]).to eq(:y)
+    expect(elems.to_ary.map(&:class)).to eq([class1] * 3)
+  end
+
+  it 'works with Paggio, .create/.new and nested blocks' do
+    elem = DOM { |d|
+      class1.new(d) {
+        d.div.noticeme
+        class1.new(d) {
+          d.div.noticeme3
+        }
+        d.div.noticeme2
+      }
+    }
+    expect(elem.class).to eq(class1)
+    expect(elem.children.length).to eq(3)
+    expect(elem.children[1].class).to eq(class1)
+    expect(elem.children[1].children.length).to eq(1)
+    expect(elem.children[0].class).to eq(Browser::DOM::Element)
+    expect(elem.children[2].class).to eq(Browser::DOM::Element)
+    expect(elem.children[1].children[0].class).to eq(Browser::DOM::Element)
+  end
+
+  it 'works with Paggio, .create/.new, nested blocks and without DOM{}' do
+    elem = class1.new {
+      div.noticeme
+      class1.new(self) {
+        div.noticeme3
+      }
+      div.noticeme2
+    }
+    expect(elem.class).to eq(class1)
+    expect(elem.children.length).to eq(3)
+    expect(elem.children[1].class).to eq(class1)
+    expect(elem.children[1].children.length).to eq(1)
+    expect(elem.children[0].class).to eq(Browser::DOM::Element)
+    expect(elem.children[2].class).to eq(Browser::DOM::Element)
+    expect(elem.children[1].children[0].class).to eq(Browser::DOM::Element)
+  end
+end