opal-jquery 0.3.0.beta1 → 0.3.0.beta2

data/lib/opal/jquery/kernel.rb

@@ -0,0 +1,11 @@
+module Kernel
+  # Alert the given message using `window.alert()`. This is a blocking
+  # method.
+  #
+  # @param msg [String] message to alert
+  # @return [nil]
+  def alert(msg)
+    `alert(msg)`
+    nil
+  end
+end

data/lib/opal/jquery/local_storage.rb

@@ -0,0 +1,87 @@
+module Browser
+  # {Browser::LocalStorage} is a simple wrapper around `localStorage` in the
+  # browser.
+  #
+  # Instead of using the class directly, the main instance {LocalStorage}
+  # should be used instead. This class can be used to wrap an instance from
+  # another window or iframe if required.
+  #
+  # ## Usage
+  #
+  # LocalStorage is not included by default when you require opal-jquery, so
+  # you will need to require it explicitly in your code:
+  #
+  #     require 'opal/jquery'
+  #     require 'opal/jquery/local_storage'
+  #
+  #     puts LocalStorage
+  #     # => #<LocalStorage>
+  #
+  # ## Example Usage
+  #
+  #     LocalStorage['foo'] = 'hello world'
+  #
+  #     LocalStorage['foo'] # => "hello world"
+  #     LocalStorage['bar'] # => nil
+  #
+  # @see LocalStorage
+  #
+  class LocalStorage
+    def initialize(storage)
+      @storage = storage
+    end
+
+    # Set a value in storage.
+    #
+    # Values stored in {LocalStorage} will be stored as strings. To store any
+    # other type of object, you will need to convert them to a string first,
+    # and then convert them back from {#[]}. For this reason it is recommended
+    # to only store {JSON} based objects in storage, so they can be easily
+    # converted back and forth.
+    #
+    # @param key [String] string key
+    # @param value [String, #to_s] string or explicitly converted object
+    def []=(key, value)
+      %x{
+        #@storage.setItem(key, value);
+        return value;
+      }
+    end
+
+    # Retrieve an object from {LocalStorage}.
+    #
+    # Only string values can be stored, so any object will be returned as a
+    # string. You will need to handle any conversion back into a normal
+    # object. {JSON.parse} could be used, for example, to parse back into
+    # arrays or hashes.
+    #
+    # If a key is not present in the storage, then `nil` will be returned.
+    #
+    # @param key [String] key to lookup
+    # @return [String, nil]
+    def [](key)
+      %x{
+        var value = #@storage.getItem(key);
+        return value == null ? nil : value;
+      }
+    end
+
+    # Removes a specific `key` from storage. If the key does not exist then
+    # there is no side effect.
+    #
+    # @param key [String] key to remove
+    def delete(key)
+      `#@storage.removeItem(key)`
+    end
+
+    # Remove all key/values from storage
+    def clear
+      `#@storage.clear()`
+    end
+  end
+end
+
+# {LocalStorage} is the top level instance of {Browser::LocalStorage} that
+# wraps `window.localStorage`, aka the `localStorage` object available on
+# the main window.
+LocalStorage = Browser::LocalStorage.new(`window.localStorage`)

data/lib/opal/jquery/rspec.rb

@@ -0,0 +1,65 @@
+module Browser
+  # When testing (using rspec), this module provides some helper methods to
+  # try and make testing a little easier.
+  #
+  # ## Usage
+  #
+  # Simply require this file somewher (usualy in `spec_helper.rb`):
+  #
+  #     require 'application'
+  #     require 'opal-rspec'
+  #     require 'opal/jquery/rspec'
+  #
+  # Once required, the module is registered with `rspec` for all example
+  # groups.
+  #
+  # ## Adding html to DOM
+  #
+  # It is often convenient to have some `HTML` code ready in the dom for
+  # testing. This helper method adds the given html string. More so, the html
+  # is then removed at the end of each test. This is cruicial as it ensures
+  # that the specified html code is inserted before each test, therefore
+  # ensuring that html code changed by a test will not affect any other tests
+  # in the same scope.
+  #
+  #     describe "Check DOM code" do
+  #       html '<div id="foo"></div>'
+  #
+  #       it "foo should exist" do
+  #         expect(Document['#foo']).to_not be_empty
+  #       end
+  #     end
+  #
+  module RSpecHelpers
+    # Add some html code to the body tag ready for testing. This will
+    # be added before each test, then removed after each test. It is
+    # convenient for adding html setup quickly. The code is wrapped
+    # inside a div, which is directly inside the body element.
+    #
+    #     describe "DOM feature" do
+    #       html <<-HTML
+    #         <div id="foo"></div>
+    #       HTML
+    #
+    #       it "foo should exist" do
+    #         Document["#foo"]
+    #       end
+    #     end
+    #
+    # @param [String] html_string html content to add
+    def html(html_string='')
+      html = %Q{<div id="opal-jquery-test-div">#{html_string}</div>}
+
+      before do
+        @_spec_html = Element.parse(html)
+        @_spec_html.append_to_body
+      end
+
+      after { @_spec_html.remove }
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.extend Browser::RSpecHelpers
+end

data/lib/opal/jquery/version.rb

@@ -1,5 +1,5 @@
 module Opal
   module JQuery
-    VERSION = '0.3.0.beta1'
+    VERSION = '0.3.0.beta2'
   end
 end

data/lib/opal/jquery/window.rb

@@ -0,0 +1,40 @@
+require 'opal/jquery/element'
+
+module Browser
+  # {Window} instances are {Native} objects used to wrap native window instances.
+  #
+  # Generally, you will want to use the top level {::Window} instance, which
+  # wraps `window` from the main page.
+  class Window
+    include Native
+
+    # Returns this {Window} instance wrapped as an {Element}. Useful for
+    # delegating jQuery events, which allows the use of `window` as target.
+    #
+    # @return [Element]
+    def element
+      @element ||= Element.find(`window`)
+    end
+
+    # @see Element#on
+    def on(*args, &block)
+      element.on(*args, &block)
+    end
+
+    # @see Element#off
+    def off(*args, &block)
+      element.off(*args, &block)
+    end
+
+    # @see Element#trigger
+    def trigger(*args)
+      element.trigger(*args)
+    end
+  end
+end
+
+# Top level {Browser::Window} instance.
+Window = Browser::Window.new(`window`)
+
+# TODO: this will be removed soon.
+$window = Window

data/opal-jquery.gemspec

@@ -15,8 +15,8 @@ Gem::Specification.new do |s|
   s.test_files     = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths  = ['lib']
 
-  s.add_runtime_dependency 'opal', '~> 0.7.0.beta1'
-  s.add_development_dependency 'opal-rspec', '~> 0.4.0.beta2'
+  s.add_runtime_dependency 'opal', '~> 0.7.0.beta3'
+  s.add_development_dependency 'opal-rspec', '~> 0.4.0.beta4'
   s.add_development_dependency 'yard'
   s.add_development_dependency 'rake'
 end

data/spec/element/after_spec.rb

@@ -1,6 +1,6 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe "Element#after" do
+describe 'Element#after' do
   html <<-HTML
     <div id="some-header" class="kapow"></div>
     <div id="foo" class="after-spec-first"></div>
@@ -8,18 +8,18 @@ describe "Element#after" do
     <div id="baz"></div>
   HTML
 
-  it "should insert the given html string after each element" do
-    el = Element.find('.after-spec-first')
-    el.size.should == 2
+  it 'should insert the given html string after each element' do
+    el = find '.after-spec-first'
+    expect(el.size).to eq(2)
 
     el.after '<p class="woosh"></p>'
 
-    Element.find('#foo').next.class_name.should == "woosh"
-    Element.find('#bar').next.class_name.should == "woosh"
+    expect(find('#foo').next.class_name).to eq('woosh')
+    expect(find('#bar').next.class_name).to eq('woosh')
   end
 
-  it "should insert the given DOM element after this element" do
-    Element.find('#baz').after Element.find('#some-header')
-    Element.find('#baz').next.id.should == "some-header"
+  it 'should insert the given DOM element after this element' do
+    find('#baz').after find('#some-header')
+    expect(find('#baz').next.id).to eq('some-header')
   end
 end

data/spec/element/animations_spec.rb

@@ -10,12 +10,12 @@ describe "Element animation methods" do
     # jQUery's animate method doesn't *always* finish on time
     # so the values are being compared using greater than
 
-    it "should animate a set of properties and values" do
+    async "should animate a set of properties and values" do
       foo = Element.find "#animate-foo"
       foo.animate :width => "200px"
 
-      set_timeout 400 do
-        (foo.css("width").to_f > 199).should eq(true)
+      delay 0.4 do
+        async { (foo.css("width").to_f > 199).should eq(true) }
       end
     end
 
@@ -23,11 +23,9 @@ describe "Element animation methods" do
       foo = Element.find "#animate-foo"
       foo.animate :width => "200px", :speed => 100
 
-      run_async {
-        set_timeout 150 do
-          (foo.css("width").to_f > 199).should eq(true)
-        end
-      }
+      delay 0.150 do
+        async { (foo.css("width").to_f > 199).should eq(true) }
+      end
     end
 
     async "should accept a block as a callback" do
@@ -36,11 +34,34 @@ describe "Element animation methods" do
         foo.add_class "finished"
       end
 
-      run_async {
-        set_timeout 405 do
-          foo.class_name.should eq("finished")
-        end
-      }
+      delay 0.405 do
+        async { foo.class_name.should eq("finished") }
+      end
     end
   end
 end
+
+describe "Element effects methods" do
+  html <<-HTML
+    <div id="effects-foo"></div>
+  HTML
+  
+  describe "#fadeout / #fadein" do
+    async "should fade the element out first" do
+      foo = Element.find "#effects-foo"
+      foo.effect(:fade_out)
+      
+      delay 1 do
+        async {
+          foo.css("display").should eq("none")
+          foo.effect(:fade_in)
+        }
+      end
+    end
+    async "should fade the element back in" do
+      delay 2 do
+        async { Element["#effects-foo"].css("display").should eq("block") }
+      end
+    end
+  end
+end

data/spec/element/attributes_spec.rb

@@ -45,19 +45,30 @@ describe Element do
       Element.find('#attr-foo')[:title].should == "Hello there!"
     end
 
-    it 'should return an empty string for an empty attribute value' do
-      Element.find('#attr-bar')[:title].should == ""
-      Element.find('#attr-baz')[:title].should == ""
+    it 'should return nil for an empty attribute' do
+      expect(Element.find('#attr-bar')[:title]).to be_nil
+      expect(Element.find('#attr-baz')[:title]).to be_nil
+    end
+  end
+
+  describe '#attr' do
+    it 'returns attributes from elements' do
+      expect(Element.find('#attr-foo').attr(:title)).to eq('Hello there!')
+    end
+
+    it 'returns nil for empty attributes' do
+      expect(Element.find('#attr-bar').attr(:title)).to be_nil
+      expect(Element.find('#attr-baz').attr(:title)).to be_nil
     end
   end
 
   describe '#[]=' do
     it 'should set the attr value on the element' do
       woosh = Element.find '#attr-woosh'
-      woosh[:title].should == ""
+      expect(woosh[:title]).to be_nil
 
       woosh[:title] = "Oranges"
-      woosh[:title].should == "Oranges"
+      expect(woosh[:title]).to eq('Oranges')
     end
 
     it 'should replace the old value for the attribute' do
@@ -72,30 +83,32 @@ describe Element do
   describe "#add_class" do
     it "should add the given class name to the element" do
       foo = Element.find '#foo'
-      foo.has_class?('lemons').should eq(false)
+      expect(foo).to_not have_class('lemons')
+
       foo.add_class 'lemons'
-      foo.has_class?('lemons').should eq(true)
+      expect(foo).to have_class('lemons')
     end
 
     it "should not duplicate class names on an element" do
       bar = Element.find '#bar'
-      bar.has_class?('apples').should eq(true)
+      expect(bar).to have_class('apples')
+
       bar.add_class 'apples'
-      bar.class_name.should == 'apples'
+      expect(bar.class_name).to eq('apples')
     end
 
     it "should return self" do
       baz = Element.find '#baz'
-      baz.add_class('oranges').should equal(baz)
-      baz.add_class('oranges').should equal(baz)
+      expect(baz.add_class('oranges')).to eq(baz)
     end
   end
 
   describe '#has_class?' do
     it "should return true if the element has the given class" do
-      Element.find('#has-foo').has_class?("apples").should eq(true)
-      Element.find('#has-foo').has_class?("oranges").should eq(false)
-      Element.find('#has-bar').has_class?("lemons").should eq(true)
+      expect(Element.find('#has-foo')).to have_class('apples')
+      expect(Element.find('#has-bar')).to have_class('lemons')
+
+      expect(Element.find('#has-foo')).to_not have_class('oranges')
     end
   end
 

data/spec/element/to_s_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe "Element#to_s" do
+  html <<-HTML
+    <div id="foo">hi</div>
+    <div class="bar"></div>
+    <p id="lol" class="bar"></div>
+  HTML
+
+  it "returns a string representation of the elements" do
+    Element.find('#foo').to_s.should == '<div id="foo">hi</div>'
+    Element.find('.bar').to_s.should == '<div class="bar"></div>, <p id="lol" class="bar"></p>'
+  end
+end

data/spec/http_spec.rb

@@ -1,46 +1,49 @@
 require "spec_helper"
 
 describe HTTP do
+  let(:good_url) { '/spec/fixtures/simple.txt' }
+  let(:json_url) { '/spec/fixtures/user.json' }
+  let(:bad_url) { '/spec/fixtures/does_not_exist.txt' }
+
   describe ".setup" do
     it 'presents the $.ajaxSetup() object as a Hash' do
-      HTTP.setup.should be_a Hash
+      expect(HTTP.setup).to be_a Hash
     end
   end
 
   describe ".get" do
-    context "with a block" do
+    describe "with a block" do
       it "returns the http object instance" do
-        HTTP.get('/spec/fixtures/simple.txt') do
-        end.should be_a HTTP
+        expect(HTTP.get(good_url) {}).to be_a HTTP
       end
 
       async "block gets called on success" do
-        HTTP.get('spec/fixtures/simple.txt') do |response|
-          run_async { response.should be_ok }
+        HTTP.get(good_url) do |response|
+          async { expect(response).to be_ok }
         end
       end
 
       async "block gets called on failure" do
-        HTTP.get('/spec/does/not/exist.txt') do |response|
-          run_async { response.should_not be_ok }
+        HTTP.get(bad_url) do |response|
+          async { expect(response).to_not be_ok }
         end
       end
     end
 
-    context "without a block" do
+    describe "without a block" do
       it "returns a promise" do
-        HTTP.get('/spec/fixtures/simple.txt').should be_a Promise
+        expect(HTTP.get(good_url)).to be_a Promise
       end
 
       async "returns a promise which accepts a then-block for successful response" do
-        HTTP.get('spec/fixtures/simple.txt').then do |response|
-          run_async { response.should be_ok }
+        HTTP.get(good_url).then do |response|
+          async { expect(response).to be_ok }
         end
       end
 
       async "returns a promise which accepts a fail-block for failing response" do
-        HTTP.get('spec/does/not/exist.txt').fail do |response|
-          run_async { response.should_not be_ok }
+        HTTP.get(bad_url).fail do |response|
+          async { expect(response).to_not be_ok }
         end
       end
     end
@@ -48,30 +51,30 @@ describe HTTP do
 
   describe '#body' do
     async 'returns the response body as a string' do
-      HTTP.get('spec/fixtures/simple.txt') do |response|
-        run_async { response.body.should == "hey" }
+      HTTP.get(good_url) do |response|
+        async { expect(response.body).to eq('hey') }
       end
     end
   end
 
   describe '#json' do
     async 'returns the json converted into native ruby objects' do
-      HTTP.get('spec/fixtures/user.json') do |response|
-        run_async { response.json.should == { 'name' => 'Adam', 'age' => 26 } }
+      HTTP.get(json_url) do |response|
+        async { expect(response.json).to eq({ 'name' => 'Adam', 'age' => 26 }) }
       end
     end
   end
 
   describe '#ok?' do
     async 'returns true when the request was a sucess' do
-      HTTP.get('spec/fixtures/simple.txt') do |response|
-        run_async { response.should be_ok }
+      HTTP.get(good_url) do |response|
+        async { expect(response).to be_ok }
       end
     end
 
     async 'returns false when the request failed' do
-      HTTP.get('spec/fixtures/non_existant.txt') do |response|
-        run_async { response.should_not be_ok }
+      HTTP.get(bad_url) do |response|
+        async { expect(response).to_not be_ok }
       end
     end
   end