opal-jquery 0.4.1 → 0.4.5

data/spec/element/method_missing_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-
-# Add our jquery extension
-%x{
-  $.fn.opal_specs_extension = function() {
-    return "foo_bar_baz";
-  };
-
-  $.fn.opal_specs_args = function() {
-    return Array.prototype.slice.call(arguments);
-  };
-}
-
-class Element
-  expose :opal_specs_extension, :opal_specs_args
-end
-
-describe "Element#exposes" do
-  it "exposes jquery plugins by given name" do
-    Element.new.opal_specs_extension.should eq("foo_bar_baz")
-  end
-
-  it "forwards any args onto native function" do
-    Element.new.opal_specs_args(:foo, 42, false).should eq([:foo, 42, false])
-  end
-
-  it "only forwards calls when a native method exists" do
-    expect {
-      Element.new.some_unknown_plugin
-    }.to raise_error(Exception)
-  end
-end

data/spec/element_spec.rb

@@ -1,261 +0,0 @@
-require "spec_helper"
-
-describe Element do
-  html <<-HTML
-    <div id="foo">
-      <div id="bar" class="apples"></div>
-    </div>
-    <div id="baz"></div>
-  HTML
-
-  describe '#on' do
-    it 'adds an event listener onto the elements' do
-      count = 0
-      foo   = Element['#foo']
-
-      foo.on(:click) { count += 1 }
-      count.should == 0
-      foo.trigger(:click)
-      count.should == 1
-      foo.trigger(:click)
-      count.should == 2
-      foo.trigger(:mousedown)
-      count.should == 2
-    end
-
-    it 'takes an optional second parameter to delegate events' do
-      count = 0
-      foo   = Element['#foo']
-      bar   = Element['#bar']
-
-      foo.on(:click, '#bar') { count += 1 }
-      count.should == 0
-      foo.trigger(:click)
-      count.should == 0
-      bar.trigger(:click)
-      count.should == 1
-      bar.trigger(:click)
-      count.should == 2
-      bar.trigger(:mousedown)
-      count.should == 2
-    end
-
-    it 'can listen for non-browser events' do
-      count = 0
-      foo   = Element['#foo']
-
-      foo.on('opal-is-mega-lolz') { count += 1 }
-      count.should == 0
-      foo.trigger('opal-is-mega-lolz')
-      count.should == 1
-      foo.trigger('opal-is-mega-lolz')
-      count.should == 2
-    end
-
-    it 'returns the given handler' do
-      handler = proc {}
-      Element['#foo'].on(:click, &handler).should == handler
-    end
-
-    it 'has an Event instance passed to the handler' do
-      foo = Element['#foo']
-      foo.on :click do |event|
-        event.should be_kind_of(Event)
-      end
-      foo.trigger(:click)
-    end
-
-    it 'has an Event instance, plus any additional parameters passed to the handler' do
-      foo = Element['#foo']
-      foo.on :bozo do |event, foo, bar, baz, buz|
-        event.should be_kind_of(Event)
-        foo.should == 'foo'
-        bar.should == 'bar'
-        baz.should == 'baz'
-        buz.should == 'buz'
-      end
-      foo.trigger(:bozo, ['foo', 'bar', 'baz', 'buz'])
-    end
-  end
-
-  describe '#off' do
-    it 'removes event handlers that were added using #on' do
-      count = 0
-      foo   = Element['#foo']
-
-      handler = foo.on(:click) { count += 1 }
-      count.should == 0
-      foo.trigger(:click)
-      count.should == 1
-      foo.off(:click, handler)
-      count.should == 1
-      foo.trigger(:click)
-      count.should == 1
-    end
-
-    it 'removes event handlers added with a selector' do
-      count = 0
-      foo   = Element['#foo']
-      bar   = Element['#bar']
-
-      handler = foo.on(:click, '#bar') { count += 1 }
-      count.should == 0
-      bar.trigger(:click)
-      count.should == 1
-      foo.off(:click, '#bar', handler)
-      count.should == 1
-      bar.trigger(:click)
-      count.should == 1
-    end
-  end
-end
-
-describe Element do
-  html <<-HTML
-    <div id="foo" class="bar"></div>
-    <div class="woosh"></div>
-    <div class="woosh"></div>
-    <div class="find-foo"></div>
-    <div class="find-bar"></div>
-    <div class="find-foo"></div>
-  HTML
-
-  describe ".[]" do
-    it "should be able to find elements with given id" do
-      Element['#foo'].class_name.should == "bar"
-      Element['#foo'].size.should == 1
-    end
-
-    it "should be able to match any valid CSS selector" do
-      Element['.woosh'].should be_kind_of(Element)
-      Element['.woosh'].size.should == 2
-    end
-
-    it "should return an empty Elements instance when not matching any elements" do
-      dom = Element['.some-non-existing-class']
-
-      dom.should be_kind_of(Element)
-      dom.size.should == 0
-    end
-
-    it "should accept an HTML string and parse it into a Elements instance" do
-      el = Element['<div id="foo-bar-baz"></div>']
-
-      el.should be_kind_of(Element)
-      el.id.should == "foo-bar-baz"
-      el.size.should == 1
-    end
-  end
-
-  describe ".find" do
-    it "should find all elements matching CSS selector" do
-      foo = Element.find '.find-foo'
-      foo.should be_kind_of(Element)
-      foo.length.should == 2
-
-      bar = Element.find '.find-bar'
-      bar.should be_kind_of(Element)
-      bar.length.should == 1
-    end
-
-    it "should return an empty Element instance with length 0 when no matching" do
-      baz = Element.find '.find-baz'
-      baz.should be_kind_of(Element)
-      baz.length.should == 0
-    end
-  end
-
-  describe '.id' do
-    it "should return a new instance with the element with given id" do
-      Element.id('foo').should be_kind_of(Element)
-      Element.id('foo').id.should == 'foo'
-    end
-
-    it "should return nil if no element could be found" do
-      Element.id('bad-element-id').should be_nil
-    end
-  end
-
-  describe '.parse' do
-    it "should return a new instance with parsed element as single element" do
-      foo = Element.parse '<div id="foo" class="bar"></div>'
-      foo.id.should == 'foo'
-      foo.class_name.should == 'bar'
-    end
-  end
-
-end
-
-describe "Element#data" do
-  html <<-HTML
-    <div id="data-foo"></div>
-    <div id="data-ford" data-authur="dent"></div>
-  HTML
-
-  it "sets a data attribute" do
-    foo = Element.id('data-foo')
-    foo.data 'bar', 'baz'
-    expect(foo.data('bar')).to eq('baz')
-  end
-
-  it "can retrieve a data attribute" do
-    expect(Element.id('data-ford').data('authur')).to eq('dent')
-  end
-
-  it "returns nil for an undefined data attribute" do
-    expect(Element.id('data-ford').data('not-here')).to be_nil
-  end
-end
-
-describe "Element#html" do
-  html <<-HTML
-    <div id="foo">bar</div>
-  HTML
-
-  it "retrieves the inner html content for the element" do
-    expect(Element.id('foo').html).to include('bar')
-  end
-
-  it "can be used to set inner html of element by passing string" do
-    foo = Element.id 'foo'
-    foo.html "different content"
-
-    expect(foo.html).to_not include('bar')
-    expect(foo.html).to include('different content')
-  end
-end
-
-describe 'Element.expose' do
-  subject(:element) { Element.new }
-  before do
-    `$.fn.exposableMethod = function() {return 123}`
-    `$.fn.exposableMethod2 = function() {return 12}`
-  end
-
-  after do
-    `delete $.fn.exposableMethod; delete $.fn.$exposableMethod;`
-    `delete $.fn.exposableMethod2; delete $.fn.$exposableMethod2;`
-  end
-
-  it 'exposes methods defined on $.fn' do
-    expect(element).not_to respond_to(:exposableMethod)
-    Element.expose :exposableMethod
-    expect(element).to respond_to(:exposableMethod)
-    expect(element.exposableMethod).to eq(123)
-  end
-
-  it 'work if exposing the same method multiple times' do
-    Element.expose :exposableMethod
-    Element.expose :exposableMethod
-    expect(element.exposableMethod).to eq(123)
-
-    Element.expose :exposableMethod, :exposableMethod
-    expect(element.exposableMethod).to eq(123)
-  end
-
-  it 'work if exposing multiple methods' do
-    Element.expose :exposableMethod, :exposableMethod2
-    expect(element.exposableMethod).to eq(123)
-    expect(element.exposableMethod2).to eq(12)
-  end
-end

data/spec/kernel_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe 'Kernel#alert' do
-  it 'returns nil' do
-    Kernel.alert('a message').should be_nil
-  end
-end