opal-browser 0.2.0 → 0.3.3

data/spec/dom/element_spec.rb

@@ -178,4 +178,46 @@ describe Browser::DOM::Element do
       expect($document.at_xpath('//div', '//span', '//[@id="lol"]')).to be_a(DOM::Element)
     end
   end
+
+  describe '#shadow' do
+    html <<-HTML
+      <div id="shadowtest"></div>
+    HTML
+
+    it 'creates a shadow root' do
+      expect($document[:shadowtest].shadow?).to be(false)
+      expect($document[:shadowtest].shadow).to be_a(DOM::ShadowRoot)
+      expect($document[:shadowtest].shadow?).to be(true)
+    end
+
+    it 'accesses a shadow root' do
+      $document[:shadowtest].shadow # Create one
+      expect($document[:shadowtest].shadow?).to be(true)
+      expect($document[:shadowtest].shadow).to be_a(DOM::ShadowRoot)
+    end
+
+    it 'works like a typical opal-browser DOM tree' do
+      DOM {
+        div.shadow_item "Hello world!"
+      }.append_to($document[:shadowtest].shadow)
+      
+      expect($document[:shadowtest].at_css(".shadow_item")).to be_nil
+      expect($document[:shadowtest].shadow.at_css(".shadow_item").text).to be("Hello world!")
+    end
+
+    it 'supports stylesheets' do
+      $document[:shadowtest].shadow << CSS {
+        rule("p") {
+          color "rgb(255, 0, 0)"
+        }
+        rule(":host") {
+          color "rgb(0, 0, 255)"
+        }
+      } << DOM { p }
+
+      expect($document[:shadowtest].shadow.at_css("p").style!.color).to be("rgb(255, 0, 0)")
+      expect($document[:shadowtest].style!.color).to be("rgb(0, 0, 255)")
+      expect($document[:shadowtest].shadow.stylesheets.count).to be(1)
+    end
+  end
 end

data/spec/dom/mutation_observer_spec.rb

@@ -7,11 +7,11 @@ describe Browser::DOM::MutationObserver do
     </div>
   HTML
 
-  async 'notifies additions' do
+  it 'notifies additions' do
+    promise = Browser::Promise.new
     obs = Browser::DOM::MutationObserver.new {|mutations|
-      async {
-        expect(mutations.first.added.first.name).to eq('DIV')
-      }
+      expect(mutations.first.added.first.name).to eq('DIV')
+      promise.resolve
 
       obs.disconnect
     }
@@ -19,13 +19,15 @@ describe Browser::DOM::MutationObserver do
     obs.observe $document[:mutate]
 
     $document[:mutate].add_child $document.create_element('div')
+
+    promise.for_rspec
   end
 
-  async 'notifies removals' do
+  it 'notifies removals' do
+    promise = Browser::Promise.new
     obs = Browser::DOM::MutationObserver.new {|mutations|
-      async {
-        expect(mutations.first.removed.first.name).to eq('SPAN')
-      }
+      expect(mutations.first.removed.first.name).to eq('SPAN')
+      promise.resolve
 
       obs.disconnect
     }
@@ -33,5 +35,7 @@ describe Browser::DOM::MutationObserver do
     obs.observe $document[:mutate]
 
     $document[:mutate].first_element_child.remove
+
+    promise.for_rspec
   end
 end if Browser::DOM::MutationObserver.supported?

data/spec/dom/node_spec.rb

@@ -18,6 +18,54 @@ describe Browser::DOM::Node do
     end
   end
 
+  describe "#clone" do
+    html '<div class="waht"><ul><li>1</li></ul></div>'
+
+    it 'should clone a DOM node with an object' do
+      obj = $document['.waht']
+      new_obj = obj.clone
+
+      expect(obj).not_to eq(new_obj) # Equality is defined as equality of DOM nodes
+      expect(obj.at_css('li')).not_to eq(new_obj.at_css('li'))
+    end
+
+    it 'should dup a DOM node with an object' do
+      obj = $document['.waht']
+      new_obj = obj.dup
+
+      expect(obj).not_to eq(new_obj) # Equality is defined as equality of DOM nodes
+      expect(obj.at_css('li')).not_to eq(new_obj.at_css('li'))
+    end
+
+    it 'should produce an object which adheres to DOM semantics' do
+      obj = $document['.waht'].clone
+      xobj = obj.clone
+      5.times do
+        obj << xobj.clone
+      end
+      expect(obj.css('li').count).to eq(6)
+    end
+
+    it 'should integrate well with NativeCachedWrapper' do
+      obj = $document['.waht'].clone
+      native = obj.to_n
+      expect(DOM(native).hash).to eq(obj.hash)
+    end
+  end
+
+  describe "#document=" do
+    html '<iframe id="diframe" src="about:blank"></iframe><div id="ddiv">hah</div>'
+
+    it 'should detach a DOM node and attach it to a new document' do
+      obj = $document['ddiv']
+      ifr = $document['diframe']
+
+      obj.document = ifr.content_document
+      expect($document['ddiv']).to eq(nil)
+      expect(obj.document).to eq(ifr.content_document)
+    end
+  end
+
   describe "#document?" do
     it "should be true for document" do
       expect($document.document?).to be_truthy

data/spec/dom_spec.rb

@@ -11,5 +11,13 @@ describe 'Kernel' do
       expect($document['.spec'].element?).to be_truthy
       expect($document['.sock'].element?).to be_truthy
     end
+
+    it "appends classes correctly" do
+      elem = DOM {
+        div.class1.class2(class: "class-3 class-4", classes: %w[class-5 class-6])
+      }
+
+      expect(elem =~ ".class1.class2.class-3.class-4.class-5.class-6").to eq(true)
+    end
   end
 end

data/spec/event_source_spec.rb

@@ -2,41 +2,44 @@ require 'spec_helper'
 require 'browser/event_source'
 
 describe Browser::EventSource do
-  async 'creates it' do
+  it 'creates it' do
+    promise = Browser::Promise.new
     Browser::EventSource.new '/events' do |es|
       es.on :open do |e|
         es.close
 
-        async {
-          expect(e.target).to be_a(Browser::EventSource)
-        }
+        expect(e.target).to be_a(Browser::EventSource)
+        promise.resolve
       end
     end
+    promise.for_rspec
   end
 
-  async 'receives an unnamed event' do
+  it 'receives an unnamed event' do
+    promise = Browser::Promise.new
     Browser::EventSource.new '/events' do |es|
       es.on :message do |e|
         e.off
         es.close
 
-        async {
-          expect(e.data).to eq('lol')
-        }
+        expect(e.data).to eq('lol')
+        promise.resolve
       end
     end
+    promise.for_rspec
   end
 
-  async 'receives a named event' do
+  it 'receives a named event' do
+    promise = Browser::Promise.new
     Browser::EventSource.new '/events' do |es|
       es.on :custom do |e|
         e.off
         es.close
 
-        async {
-          expect(e.data).to eq('omg')
-        }
+        expect(e.data).to eq('omg')
+        promise.resolve
       end
     end
+    promise.for_rspec
   end
 end if Browser::EventSource.supported?

data/spec/{dom/event_spec.rb → event_spec.rb}

@@ -1,6 +1,7 @@
 require 'spec_helper'
+require 'browser/event'
 
-describe Browser::DOM::Event do
+describe Browser::Event do
   html <<-HTML
     <div id="event-spec">
       u wot m8
@@ -40,39 +41,46 @@ describe Browser::DOM::Event do
       expect(count).to eq(2)
     end
 
-    async "passes an event to the handler" do
+    it "passes an event to the handler" do
       elem = $document["event-spec"]
 
+      promise = Browser::Promise.new
+
       elem.on :click do |event|
-        async {
-          expect(event).to be_a(Browser::DOM::Event)
-        }
+        expect(event).to be_a(Browser::Event)
+        promise.resolve
       end
 
       elem.trigger :click
+
+      promise.for_rspec
     end
 
-    async "passes additional arguments to the handler" do
+    it "passes additional arguments to the handler" do
       elem = $document["event-spec"]
 
+      promise = Browser::Promise.new
+
       elem.on :bazinga do |event, foo, bar, baz|
-        async {
-          expect(foo).to eq(1)
-          expect(bar).to eq(2)
-          expect(baz).to eq(3)
-        }
+        expect(foo).to eq(1)
+        expect(bar).to eq(2)
+        expect(baz).to eq(3)
+        promise.resolve
       end
 
       elem.trigger :bazinga, 1, 2, 3
+
+      promise.for_rspec
     end
 
-    async "works with delegated events" do
+    it "works with delegated events" do
       elem = $document["event-spec"]
 
+      promise = Browser::Promise.new
+
       elem.on :bazinga, 'span.nami' do
-        async {
-          expect(true).to be_truthy
-        }
+        expect(true).to be_truthy
+        promise.resolve
       end
 
       elem.add_child DOM { span.nami }
@@ -80,6 +88,27 @@ describe Browser::DOM::Event do
       after 0.01 do
         elem.first_element_child.trigger :bazinga
       end
+
+      promise.for_rspec
+    end
+  end
+
+  describe "#one" do
+    it "fires once, passes arguments, works with custom events" do
+      count = 0
+      elem  = $document["event-spec"]
+
+      elem.one :testone do |event, a, b, c|
+        count += a + b*c
+      end
+
+      expect(count).to eq(0)
+      elem.trigger :testone, 1, 2, 3
+      expect(count).to eq(7)
+      elem.trigger :testone, 2, 3, 4
+      expect(count).to eq(7)
+      elem.trigger :testone, 3, 4, 5
+      expect(count).to eq(7)
     end
   end
 

data/spec/history_spec.rb

@@ -19,39 +19,43 @@ describe Browser::History do
   end
 
   describe '#back' do
-    async 'should go back once' do
+    it 'should go back once' do
       expect($window.history.current).to eq('/')
       $window.history.push('/wut')
       expect($window.history.current).to eq('/wut')
 
-      $window.on 'pop:state' do |e|
-        e.off
+      promise = Browser::Promise.new
 
-        async {
-          expect($window.history.current).to eq('/')
-        }
+      $window.one 'pop:state' do |e|
+        expect($window.history.current).to eq('/')
+        promise.resolve
       end
 
       $window.history.back
+      promise.for_rspec
     end
   end
 
   describe '#state' do
-    async 'gets the right state' do
-      $window.history.push('/wut', 42)
-      $window.history.state.should eq(42)
-      $window.history.push('/omg', 23)
-      $window.history.state.should eq(23)
-
-      $window.on 'pop:state' do |e|
-        e.off
-
-        async {
+    it 'gets the right state' do
+      # XX: The previous test creates a race condition with this one.
+      # Adding a delay fixes it.
+      promise = Browser::Promise.new
+
+      after 0.05 do
+        $window.history.push('/wut', 42)
+        $window.history.state.should eq(42)
+        $window.history.push('/omg', 23)
+        $window.history.state.should eq(23)
+
+        $window.one 'pop:state' do |e|
           expect(true).to eq(true)
-        }
-      end
+          promise.resolve
+        end
 
-      $window.history.back(2)
+        $window.history.back(2)
+      end
+      promise.for_rspec
     end
   end if Browser.supports? 'History.state'
 end if Browser::History.supported?

data/spec/http_spec.rb

@@ -2,20 +2,15 @@ require 'spec_helper'
 require 'browser/http'
 
 describe Browser::HTTP do
-  let :path do
-    '/http'
-  end
+  let(:path) { '/http' }
+  let(:path_file) { '/http-file' }
 
   describe '.get' do
-    async 'fetches a path' do
+    it 'fetches a path' do
       Browser::HTTP.get(path).then {|res|
-        async {
-          expect(res.text).to eq('lol')
-        }
+        expect(res.text).to eq('lol')
       }.rescue {
-        async {
-          fail
-        }
+        fail
       }
     end
   end
@@ -27,15 +22,11 @@ describe Browser::HTTP do
   end
 
   describe '.post' do
-    async 'sends parameters properly' do
+    it 'sends parameters properly' do
       Browser::HTTP.post(path, lol: 'wut').then {|res|
-        async {
-          expect(res.text).to eq('ok')
-        }
+        expect(res.text).to eq('ok')
       }.rescue {
-        async {
-          fail
-        }
+        fail
       }
     end
   end
@@ -44,18 +35,19 @@ describe Browser::HTTP do
     it 'sends parameters properly' do
       expect(Browser::HTTP.post!(path, lol: 'wut').text).to eq('ok')
     end
+
+    it 'sends files properly' do
+      file = Browser::File.create(["content"], "yay.txt", type: "text/plain")
+      expect(Browser::HTTP.post!(path_file, lol: 'wut', file: file).text).to eq('ok')
+    end
   end
 
   describe '.put' do
-    async 'sends parameters properly' do
+    it 'sends parameters properly' do
       Browser::HTTP.put(path, lol: 'wut').then {|res|
-        async {
-          expect(res.text).to eq('ok')
-        }
+        expect(res.text).to eq('ok')
       }.rescue {
-        async {
-          fail
-        }
+        fail
       }
     end
   end
@@ -67,15 +59,11 @@ describe Browser::HTTP do
   end
 
   describe '.delete' do
-    async 'fetches a path' do
+    it 'fetches a path' do
       Browser::HTTP.delete(path).then {|res|
-        async {
-          expect(res.text).to eq('lol')
-        }
+        expect(res.text).to eq('lol')
       }.rescue {
-        async {
-          fail
-        }
+        fail
       }
     end
   end

data/spec/immediate_spec.rb

@@ -3,12 +3,13 @@ require 'browser/immediate'
 
 describe Proc do
   describe '#defer' do
-    async 'defers the parameters' do
+    it 'defers the parameters' do
+      promise = Browser::Promise.new
       proc {|a|
-        async {
-          expect(a).to eq(42)
-        }
+        expect(a).to eq(42)
+        promise.resolve
       }.defer(42)
+      promise.for_rspec
     end
   end
 end

data/spec/interval_spec.rb

@@ -3,48 +3,57 @@ require 'browser/interval'
 
 describe Browser::Window do
   describe '#every' do
-    async 'calls the block multiple times' do
+    it 'calls the block multiple times' do
       x = 0
 
+      promise = Browser::Promise.new
       $window.every 0.3 do
         x += 1
 
-        async {
+        if x == 3
           expect(true).to be_truthy
-        } if x == 3
+          promise.resolve
+        end
       end
+      promise.for_rspec
     end
   end
 end
 
 describe Kernel do
   describe '#every' do
-    async 'calls the block multiple times' do
+    it 'calls the block multiple times' do
       x = 0
 
+      promise = Browser::Promise.new
       every 0.3 do
         x += 1
 
-        async {
+        if x == 3
           expect(true).to be_truthy
-        } if x == 3
+          promise.resolve
+        end
       end
+      promise.for_rspec
     end
   end
 end
 
 describe Proc do
   describe '#every' do
-    async 'calls the block multiple times' do
+    it 'calls the block multiple times' do
       x = 0
 
+      promise = Browser::Promise.new
       -> {
         x += 1
 
-        async {
+        if x == 3
           expect(true).to be_truthy
-        } if x == 3
+          promise.resolve
+        end
       }.every 0.3
+      promise.for_rspec
     end
   end
 end

data/spec/native_cached_wrapper_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Browser::NativeCachedWrapper do
+  it 'deduplicates DOM objects' do
+    expect($document.at_css("body").hash).to eq($document.body.hash)
+    expect($document.body.hash).not_to eq($document.body.dup.hash) # Should dup/clone have different semantics?
+    expect($document.body.hash).not_to eq($document.head.hash)
+  end
+
+  it 'accurately intercepts the last new call' do
+    class Demo
+      include Browser::NativeCachedWrapper
+
+      def self.new(arg1, arg2)
+        super(`{arg1: #{arg1}, arg2: #{arg2}}`)
+      end
+
+      def data
+        [:data, `#@native.arg1`, `#@native.arg2`]
+      end
+    end
+
+    class SuperDemo < Demo
+      def self.new(arg1, arg2, arg3)
+        super("superdemo", "#{arg1} - #{arg2} - #{arg3}")
+      end
+    end
+
+    expect(Demo.new("a", "b").data).to eq([:data, "a", "b"])
+    expect(SuperDemo.new("1", "2", "3").data).to eq([:data, "superdemo", "1 - 2 - 3"])
+  end
+
+  html <<-HTML
+    <iframe id='ifr' src='about:blank' sandbox=''></iframe>
+  HTML
+
+  it 'supports restricted objects' do
+    # Window won't be restricted
+    expect($window.restricted?).to eq(false)
+    # Iframe itself won't be restricted
+    expect($document['ifr'].restricted?).to eq(false)
+    # But its content_window will be (due to CORS)
+    expect($document['ifr'].content_window.restricted?).to eq(true)
+  end
+end
+