opal-jquery 0.0.13 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 10a59c85f98bfc9492071646b6bfb475fa901bc9
+  data.tar.gz: 482d3c0bdc6c64a56e785909f111af4c2ff2abf9
+SHA512:
+  metadata.gz: 4532a13456f025938b72ca671bd9bba3921f47fc78992e74172763f0559e254a418bbd5f261024b30fbf6222600ed54a724a34d5b114d8290350df4a47b71634
+  data.tar.gz: 8608e4673b228258dec7a972fc3257f9be3cb6dc5af1f190b76c7811eef3fbe200757b11b2dd38a9ca23e3012d4bdfdea4000fee8ddc9921cfcfb7b169c59da4

data/Gemfile

@@ -2,6 +2,3 @@ source "https://rubygems.org"
 gemspec
 
 gem 'rake'
-gem 'opal'
-gem 'opal-spec'
-gem 'opal-sprockets'

data/README.md

@@ -10,6 +10,227 @@ See the [website for documentation](http://opalrb.org/jquery).
 
 ## Documentation
 
+```ruby
+elements = Element.find('.foo')
+# => [<div class="foo">, ...]
+
+elements.class
+# => JQuery
+
+elements.on(:click) do
+  alert "element was clicked"
+end
+```
+
+### Getting Started
+
+#### Installation
+
+Install opal-jquery from RubyGems:
+
+```
+$ gem install opal-jquery
+```
+
+Or include it in your Gemfile for Bundler:
+
+```ruby
+gem 'opal-jquery'
+```
+
+### Interacting with the DOM
+
+#### Finding elements
+
+opal-jquery provides the `Element` class, which can be used to find elements in
+the current document:
+
+```ruby
+Element.find('#header')
+```
+
+`Element.find` is aliased to `Element[]`:
+
+```ruby
+Element['.my-class']
+```
+
+These methods acts just like `$('selector')`, and can use any jQuery
+compatible selector:
+
+```ruby
+Element.find('#navigation li:last')
+```
+
+The result is just a jQuery instance, which is toll-free bridged to
+instances of the `Element` class in ruby:
+
+```ruby
+Element.find('.foo').class
+# => Element
+```
+
+Instances of `Element` also have the `#find` method available for
+finding elements within the scope of each DOM node represented by
+the instance:
+
+```ruby
+el = Element.find('#header')
+el.find '.foo'
+# => #<Element .... >
+```
+
+#### Running code on document ready
+
+Just like jQuery, opal-jquery requires the document to be ready to
+be able to fully interact with the page. Any top level access should
+use the `ready?` method:
+
+```ruby
+Document.ready? do
+  alert "document is ready to go!"
+end
+```
+
+The `Kernel#alert` method is shown above too.
+
+#### Event handling
+
+The `Element#on` method is used to attach event handlers to elements:
+
+```ruby
+Element.find('#header').on :click do
+  puts "The header was clicked!"
+end
+```
+
+Selectors can also be passed as a second argument to handle events
+on certain children:
+
+```ruby
+Element.find('#header').on(:click, '.foo') do
+  puts "An element with a 'foo' class was clicked"
+end
+```
+
+An `Event` instance is optionally passed to block handlers as well,
+which is toll-free bridged to jquery events:
+
+```ruby
+Element.find('#my_link').on(:click) do |evt|
+  evt.stop_propagation
+  puts "stopped the event!"
+end
+```
+
+#### CSS styles and classnames
+
+The various jQuery methods are available on `Element` instances:
+
+```ruby
+foo = Element.find('.foo')
+
+foo.add_class 'blue'
+foo.remove_class 'foo'
+foo.toggle_class 'selected'
+```
+
+There are also added convenience methods for opal-jquery:
+
+```ruby
+foo = Element.find('#header')
+
+foo.class_name
+# => 'red lorry'
+
+foo.class_name = 'yellow house'
+
+foo.class_name
+# => 'yellow house'
+```
+
+`Element#css` also exists for getting/setting css styles:
+
+```ruby
+el = Element.find('#container')
+el.css 'color', 'blue'
+el.css 'color'
+# => 'blue'
+```
+
+### HTTP/AJAX requests
+
+jQuery's Ajax implementation is also wrapped in the top level HTTP
+class.
+
+```ruby
+HTTP.get("/users/1.json") do |response|
+  puts response.body
+  # => "{\"name\": \"Adam Beynon\"}"
+end
+```
+
+The block passed to this method is used as the handler when the request
+succeeds, as well as when it fails. To determine whether the request
+was successful, use the `ok?` method:
+
+```ruby
+HTTP.get("/users/2.json") do |response|
+  if response.ok?
+    alert "successful!"
+  else
+    alert "request failed :("
+  end
+end
+```
+
+It is also possible to use a different handler for each case:
+
+```ruby
+request = HTTP.get("/users/3.json")
+
+request.callback {
+  puts "Request worked!"
+}
+
+request.errback {
+  puts "Request didn't work :("
+}
+```
+
+The request is actually triggered inside the `HTTP.get` method, but due
+to the async nature of the request, the callback and errback handlers can
+be added anytime before the request returns.
+
+#### Handling responses
+
+Web apps deal with JSON responses quite frequently, so there is a useful
+`#json` helper method to get the JSON content from a request:
+
+```ruby
+HTTP.get("/users.json") do |response|
+  puts response.body
+  puts response.json
+end
+
+# => "[{\"name\": \"Adam\"},{\"name\": \"Ben\"}]"
+# => [{"name" => "Adam"}, {"name" => "Ben"}]
+```
+
+The `#body` method will always return the raw response string.
+
+If an error is encountered, then the `#status_code` method will hold the
+specific error code from the underlying request:
+
+```ruby
+request = HTTP.get("/users/3.json")
+
+request.callback { puts "it worked!" }
+
+request.errback { |response|
+  puts "failed with status #{response.status_code}"
+}
+```
 ### HTTP
 
 The `HTTP` class wraps jQuery's ajax request into a ruby class.
@@ -47,6 +268,12 @@ Run the tests inside a phantom.js runner:
 
     $ bundle exec rake
 
+### Zepto
+
+opal-jquery also supports zepto. To run specs for zepto use the rake task:
+
+    $ bundle exec rake zepto
+
 ##  License
 
 (The MIT License)

data/Rakefile

@@ -3,4 +3,50 @@ Bundler.require
 Bundler::GemHelper.install_tasks
 
 require 'opal/spec/rake_task'
-Opal::Spec::RakeTask.new(:default)
+Opal::Spec::RakeTask.new(:default) do |s|
+  s.index_path = 'spec/jquery/index.html'
+end
+
+Opal::Spec::RakeTask.new(:zepto) do |s|
+  s.index_path = 'spec/zepto/index.html'
+end
+
+desc "Build build/opal-jquery.js"
+task :dist do
+  require 'fileutils'
+  FileUtils.mkdir_p 'build'
+
+  src = Opal::Builder.build('opal-jquery')
+  min = uglify src
+  gzp = gzip min
+
+  File.open('build/opal-jquery.js', 'w+') do |out|
+    out << src
+  end
+
+  puts "development: #{src.size}, minified: #{min.size}, gzipped: #{gzp.size}"
+end
+
+# Used for uglifying source to minify
+def uglify(str)
+  IO.popen('uglifyjs', 'r+') do |i|
+    i.puts str
+    i.close_write
+    return i.read
+  end
+rescue Errno::ENOENT
+  $stderr.puts '"uglifyjs" command not found (install with: "npm install -g uglify-js")'
+  nil
+end
+
+# Gzip code to check file size
+def gzip(str)
+  IO.popen('gzip -f', 'r+') do |i|
+    i.puts str
+    i.close_write
+    return i.read
+  end
+rescue Errno::ENOENT
+  $stderr.puts '"gzip" command not found, it is required to produce the .gz version'
+  nil
+end

data/config.ru

@@ -5,5 +5,6 @@ run Opal::Server.new { |s|
   s.main = 'opal/spec/sprockets_runner'
   s.append_path 'spec'
   s.debug = false
+  s.index_path = 'spec/jquery/index.html'
 }
 

data/lib/opal/jquery.rb

@@ -1,4 +1,4 @@
 require 'opal'
 require 'opal/jquery/version'
 
-Opal.append_path File.expand_path('../../../opal', __FILE__)
+Opal.append_path File.expand_path('../../../opal', __FILE__).untaint

data/lib/opal/jquery/version.rb

@@ -1,5 +1,5 @@
 module Opal
   module JQuery
-    VERSION = '0.0.13'
+    VERSION = '0.1.0'
   end
 end

data/opal-jquery.gemspec

@@ -15,6 +15,6 @@ 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.4.4'
-  s.add_development_dependency 'opal-spec', '>= 0.3.0'
+  s.add_runtime_dependency 'opal', '~> 0.5.0'
+  s.add_development_dependency 'opal-spec', '~> 0.3.0'
 end

data/opal/opal-jquery.rb

@@ -1,3 +1,4 @@
+require 'opal-jquery/window'
 require 'opal-jquery/document'
 require 'opal-jquery/element'
 require 'opal-jquery/event'

data/opal/opal-jquery/element.rb

@@ -8,9 +8,12 @@ class Element
     else if (root.Zepto) {
       dom_class = Zepto.zepto.Z;
     }
+    else {
+      throw new Error("jQuery must be included before opal-jquery");
+    }
 
-    #{self}._proto = dom_class.prototype, def = #{self}._proto;
-    dom_class.prototype._klass = #{self};
+    self._proto = dom_class.prototype, def = self._proto;
+    dom_class.prototype._klass = self;
   }
 
   include Kernel
@@ -48,7 +51,7 @@ class Element
     %x{
       for (var i = 0, length = methods.length, method; i < length; i++) {
         method = methods[i];
-        #{self}._proto['$' + method] = #{self}._proto[method];
+        self._proto['$' + method] = self._proto[method];
       }
 
       return nil;
@@ -63,7 +66,7 @@ class Element
   expose :hide, :show, :toggle, :children, :blur, :closest, :data
   expose :focus, :find, :next, :siblings, :text, :trigger, :append
   expose :height, :width, :serialize, :is, :filter, :last, :first
-  expose :wrap, :stop, :clone
+  expose :wrap, :stop, :clone, :empty
 
   # We alias some jquery methods to common ruby method names.
   alias succ next
@@ -94,7 +97,7 @@ class Element
   end
 
   def [](name)
-    `#{self}.attr(name) || ""`
+    `self.attr(name) || ""`
   end
 
   def add_attribute name
@@ -102,32 +105,23 @@ class Element
   end
 
   def has_attribute? name
-    `!!#{self}.attr(name)`
+    `!!self.attr(name)`
   end
 
   def append_to_body
-    `#{self}.appendTo(document.body)`
+    `self.appendTo(document.body)`
   end
 
   def append_to_head
-    `#{self}.appendTo(document.head)`
+    `self.appendTo(document.head)`
   end
 
   # Returns the element at the given index as a new `DOM` instance.
   # Negative indexes can be used and are counted from the end. If the
   # given index is outside the range then `nil` is returned.
-  #
-  # @example
-  #
-  #   DOM('.foo')[0]    # => first element in collection
-  #   DOM('.foo')[-1]   # => last element from collection
-  #   DOM('.foo')[100]  # => returns nil if index outside range
-  #
-  # @param [Numeric] index the index to get
-  # @return [DOM, nil] returns new collection with returned element
   def at(index)
     %x{
-      var length = #{self}.length;
+      var length = self.length;
 
       if (index < 0) {
         index += length;
@@ -137,70 +131,43 @@ class Element
         return nil;
       }
 
-      return $(#{self}[index]);
+      return $(self[index]);
     }
   end
 
-  # Returns the CSS class name of the firt element in #{self} collection.
+  # Returns the CSS class name of the firt element in self collection.
   # If the collection is empty then an empty string is returned. Only
   # the class name of the first element will ever be returned.
-  #
-  # @example
-  #
-  #   DOM('<p class="foo"></p>').class_name
-  #   # => "foo"
-  #
-  # @return [String] the class name
   def class_name
     %x{
-      var first = #{self}[0];
+      var first = self[0];
       return (first && first.className) || "";
     }
   end
 
-  # Sets the CSS class name of every element in #{self} collection to the
-  # given string. #{self} does not append the class names, it replaces
+  # Sets the CSS class name of every element in self collection to the
+  # given string. self does not append the class names, it replaces
   # the entire current class name.
-  #
-  # @example
-  #
-  #   DOM('#foo').class_name = "title"
-  #
-  # @param [String] name the class name to set on each element
-  # @return [DOM] returns the receiver
   def class_name=(name)
     %x{
-      for (var i = 0, length = #{self}.length; i < length; i++) {
-        #{self}[i].className = name;
+      for (var i = 0, length = self.length; i < length; i++) {
+        self[i].className = name;
       }
     }
     self
   end
 
-  # Get or set css properties on each element in #{self} collection. If
+  # Get or set css properties on each element in self collection. If
   # only the `name` is given, then that css property name is read from
   # the first element in the collection and returned. If the `value`
   # property is also given then the given css property is set to the
-  # given value for each of the elements in #{self} collection. The
+  # given value for each of the elements in self collection. The
   # property can also be a hash of properties and values.
-  #
-  # @example
-  #
-  #   foo = DOM '#foo'
-  #   foo.css 'background-color'            # => "red"
-  #   foo.css 'background-color', 'green'
-  #   foo.css 'background-color'            # => "green"
-  #   foo.css :width => '200px'
-  #
-  # @param [String] name the css property to get/set
-  # @param [String] value optional value to set
-  # @param [Hash] set of css properties and values
-  # @return [String, DOM] returns css value or the receiver
   def css(name, value=nil)
     if value.nil? && name.is_a?(String)
-      return `#{self}.css(name)`
+      return `self.css(name)`
     else
-      name.is_a?(Hash) ? `#{self}.css(#{name.to_n})` : `#{self}.css(name, value)`
+      name.is_a?(Hash) ? `self.css(#{name.to_n})` : `self.css(name, value)`
     end
     self
   end
@@ -209,21 +176,10 @@ class Element
   # set of css properties and values to animate to. The first parameter
   # also accepts a special :speed value to set animation speed. If a block
   # is given, the block is run as a callback when the animation finishes.
-  #
-  # @example
-  #
-  #   foo = DOM "#foo"
-  #   foo.animate :height => "200px", "margin-left" => "10px"
-  #   bar.animate :top => "30px", :speed => 100 do
-  #     bar.add_class "finished"
-  #   end
-  #
-  # @param [Hash] css properties and and values. Also accepts speed param.
-  # @return [DOM] receiver
   def animate(params, &block)
     speed = params.has_key?(:speed) ? params.delete(:speed) : 400
     %x{
-      #{self}.animate(#{params.to_n}, #{speed}, function() {
+      self.animate(#{params.to_n}, #{speed}, function() {
         #{block.call if block_given?}
       })
     }
@@ -236,93 +192,61 @@ class Element
     name = name.gsub(/_\w/) { |match| match[1].upcase }
     args = args.map { |a| a.to_n if a.respond_to? :to_n }.compact
     args << `function() { #{block.call if block_given?} }`
-    `#{self}[#{name}].apply(#{self}, #{args})`
+    `self[#{name}].apply(self, #{args})`
   end
 
   def visible?
-    `#{self}.is(':visible')`
+    `self.is(':visible')`
   end
 
   def offset
-    Hash.from_native(`#{self}.offset()`)
+    Hash.from_native(`self.offset()`)
   end
 
-  # Yields each element in #{self} collection in turn. The yielded element
-  # is wrapped as a `DOM` instance.
-  #
-  # @example
-  #
-  #   DOM('.foo').each { |e| puts "The element id: #{e.id}" }
-  #
-  # @return returns the receiver
   def each
-    `for (var i = 0, length = #{self}.length; i < length; i++) {`
-      yield `$(#{self}[i])`
+    `for (var i = 0, length = self.length; i < length; i++) {`
+      yield `$(self[i])`
     `}`
     self
   end
 
-  # return an opal array mapped with block yielded for any element
-  #
-  # @example
-  #
-  #  list = Document.find('table.players td.surname').map  {|el| el.html }
-  #
-  # @return an Array
-  def map
-    list = []
-    each {|el| list << yield(el) }
-    list
-  end
-
-  # return an opal Array of elements
-  #
-  # @example
-  #
-  # Document.find('table.players td.surname').to_a.last
-  #
-  # @return an Array
-  def to_a
-    map {|el| el }
-  end
-
   def first
-    `#{self}.length ? #{self}.first() : nil`
+    `self.length ? self.first() : nil`
   end
 
   def html
-    `#{self}.html() || ""`
+    `self.html() || ""`
   end
 
   def id
     %x{
-      var first = #{self}[0];
+      var first = self[0];
       return (first && first.id) || "";
     }
   end
 
   def id=(id)
     %x{
-      var first = #{self}[0];
+      var first = self[0];
 
       if (first) {
         first.id = id;
       }
 
-      return #{self};
+      return self;
     }
   end
 
   def tag_name
-    `#{self}.length > 0 ? #{self}[0].tagName.toLowerCase() : #{nil}`
+    `self.length > 0 ? self[0].tagName.toLowerCase() : #{nil}`
   end
 
   def inspect
     %x{
       var val, el, str, result = [];
 
-      for (var i = 0, length = #{self}.length; i < length; i++) {
-        el  = #{self}[i];
+      for (var i = 0, length = self.length; i < length; i++) {
+        el  = self[i];
         str = "<" + el.tagName.toLowerCase();
 
         if (val = el.id) str += (' id="' + val + '"');
@@ -336,31 +260,59 @@ class Element
   end
 
   def length
-    `#{self}.length`
+    `self.length`
   end
 
   def any?
-    `#{self}.length > 0`
+    `self.length > 0`
   end
 
   def empty?
-    `#{self}.length === 0`
+    `self.length === 0`
   end
 
   alias empty? none?
 
   def on(name, sel = nil, &block)
-    `sel == nil ? #{self}.on(name, block) : #{self}.on(name, sel, block)`
+    %x{
+      var wrapper = function(evt) {
+        if (evt.preventDefault) {
+          evt = #{Event.new `evt`};
+        }
+
+        return block.apply(null, arguments);
+      };
+
+      block._jq_wrap = wrapper;
+
+      if (sel == nil) {
+        self.on(name, wrapper);
+      }
+      else {
+        self.on(name, sel, wrapper);
+      }
+    }
+
     block
   end
 
   def off(name, sel, block = nil)
-    `block == nil ? #{self}.off(name, sel) : #{self}.off(name, sel, block)`
+    %x{
+      if (sel == null) {
+        return self.off(name);
+      }
+      else if (block === nil) {
+        return self.off(name, sel._jq_wrap);
+      }
+      else {
+        return self.off(name, sel, block._jq_wrap);
+      }
+    }
   end
 
   alias size length
 
   def value
-    `#{self}.val() || ""`
+    `self.val() || ""`
   end
 end

data/opal/opal-jquery/event.rb

@@ -1,30 +1,49 @@
-#Class.bridge_class 'Event', `$.Event`
-
 # Wraps native jQuery event objects.
 class Event
-  %x{
-    var bridge_class = $.Event;
-
-    #{self}._proto = bridge_class.prototype, def = #{self}._proto;
-    bridge_class.prototype._klass = #{self};
-  }
-
-  include Kernel
+  def initialize(native)
+    @native = native
+  end
 
   def [](name)
-    `#{self}[name]`
+    `#@native[name]`
   end
 
-  def ctrl_key
-    @ctrlKey
+  def type
+    `#@native.type`
   end
 
+  ##
+  # Element
+
   def current_target
-    `$(#{self}.currentTarget)`
+    `$(#@native.currentTarget)`
   end
 
+  def target
+    `$(#@native.target)`
+  end
+
+  ##
+  # Propagation
+
   def default_prevented?
-    `#{self}.isDefaultPrevented()`
+    `#@native.isDefaultPrevented()`
+  end
+
+  def prevent_default
+    `#@native.preventDefault()`
+  end
+
+  def propagation_stopped?
+    `#@native.propagationStopped()`
+  end
+
+  def stop_propagation
+    `#@native.stopPropagation()`
+  end
+
+  def stop_immediate_propagation
+    `#@native.stopImmediatePropagation()`
   end
 
   # Stops propagation and prevents default action.
@@ -33,39 +52,34 @@ class Event
     prevent_default
   end
 
-  alias_native :prevent_default, :preventDefault
+  ##
+  # Keyboard/Mouse/Touch
 
   def page_x
-    `#{self}.pageX`
+    `#@native.pageX`
   end
 
   def page_y
-    `#{self}.pageY`
-  end
-
-  alias_native :propagation_stopped?, :propagationStopped
-
-  alias_native :stop_propagation, :stopPropagation
-
-  alias_native :stop_immediate_propagation, :stopImmediatePropagation
-
-  def target
-    `$(#{self}.target)`
+    `#@native.pageY`
   end
 
   def touch_x
-    `#{self}.originalEvent.touches[0].pageX`
+    `#@native.originalEvent.touches[0].pageX`
   end
 
   def touch_y
-    `#{self}.originalEvent.touches[0].pageY`
+    `#@native.originalEvent.touches[0].pageY`
   end
 
-  def type
-    @type
+  def ctrl_key
+    `#@native.ctrlKey`
+  end
+
+  def key_code
+    `#@native.keyCode`
   end
 
   def which
-    @which
+    `#@native.which`
   end
 end

data/opal/opal-jquery/kernel.rb

@@ -1,5 +1,6 @@
 module Kernel
   def alert(msg)
     `alert(msg)`
+    nil
   end
 end

data/opal/opal-jquery/window.rb

@@ -0,0 +1,4 @@
+require 'opal-jquery/element'
+
+Window = Element.find `window`
+$window = Window

data/spec/element/iterable_spec.rb

@@ -37,12 +37,12 @@ describe Element do
     it "should return a list of class Array" do
       Element.find('table.players td.surname').to_a.class.should == Array
     end
-    
+
     it "should check first and last element" do
       Element.find('table.players td.surname').to_a.first.html == "rossi"
       Element.find('table.players td.surname').to_a.last.html == "bianchi"
     end
-    
+
     it "should get only element with class surname" do
       Element.find('table.players td').to_a.select {|el| el.has_class?('surname') }.
       map {|el| el.class }.uniq  == ['surname']

data/spec/http_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe HTTP do
   describe '#body' do
     async 'returns the response body as a string' do
-      HTTP.get('spec/data/simple.txt') do |response|
+      HTTP.get('spec/fixtures/simple.txt') do |response|
         run_async { response.body.should == "hey" }
       end
     end
@@ -11,7 +11,7 @@ describe HTTP do
 
   describe '#callback' do
     async 'can add a success callback after the request is sent' do
-      http = HTTP.get('spec/data/simple.txt')
+      http = HTTP.get('spec/fixtures/simple.txt')
       http.callback do |response|
         run_async { response.ok?.should be_true }
       end
@@ -20,7 +20,7 @@ describe HTTP do
 
   describe '#callback' do
     async 'can add a failure callback after the request is sent' do
-      http = HTTP.get('spec/data/bad_url.txt')
+      http = HTTP.get('spec/fixtures/bad_url.txt')
       http.errback do |response|
         run_async { response.ok?.should be_false }
       end
@@ -29,7 +29,7 @@ describe HTTP do
 
   describe '#json' do
     async 'returns the json converted into native ruby objects' do
-      HTTP.get('spec/data/user.json') do |response|
+      HTTP.get('spec/fixtures/user.json') do |response|
         run_async { response.json.should == { 'name' => 'Adam', 'age' => 26 } }
       end
     end
@@ -37,13 +37,13 @@ describe HTTP do
 
   describe '#ok?' do
     async 'returns true when the request was a sucess' do
-      HTTP.get('spec/data/simple.txt') do |response|
+      HTTP.get('spec/fixtures/simple.txt') do |response|
         run_async { response.ok?.should be_true }
       end
     end
-    
+
     async 'returns false when the request failed' do
-      HTTP.get('spec/data/non_existant.txt') do |response|
+      HTTP.get('spec/fixtures/non_existant.txt') do |response|
         run_async { response.ok?.should be_false }
       end
     end

data/spec/jquery/index.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+<head>
+</head>
+<body>
+  <%= javascript_include_tag 'jquery/jquery' %>
+  <%= javascript_include_tag @server.main %>
+</body>
+</html>

data/spec/kernel_spec.rb

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

data/spec/spec_helper.rb

@@ -1,34 +1,35 @@
-require 'jquery'
 require 'opal-spec'
 require 'opal-jquery'
 
-module OpalSpec
-  class Example
+module JqueryHelpers
+  # 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>}
 
-    # 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 self.html(html_string='')
-      html = '<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 }
+    before do
+      @_spec_html = Element.parse(html)
+      @_spec_html.append_to_body
     end
+
+    after { @_spec_html.remove }
   end
 end
+
+class OpalSpec::Example
+  extend JqueryHelpers
+end

data/spec/zepto/index.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+<head>
+</head>
+<body>
+  <%= javascript_include_tag 'zepto/zepto' %>
+  <%= javascript_include_tag @server.main %>
+</body>
+</html>

metadata

@@ -1,46 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: opal-jquery
 version: !ruby/object:Gem::Version
-  version: 0.0.13
-  prerelease: 
+  version: 0.1.0
 platform: ruby
 authors:
 - Adam Beynon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-13 00:00:00.000000000 Z
+date: 2013-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 0.4.4
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 0.4.4
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: opal-spec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
         version: 0.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
         version: 0.3.0
 description: Opal DOM library for jquery
@@ -73,8 +68,7 @@ files:
 - opal/opal-jquery/event.rb
 - opal/opal-jquery/http.rb
 - opal/opal-jquery/kernel.rb
-- spec/data/simple.txt
-- spec/data/user.json
+- opal/opal-jquery/window.rb
 - spec/document_spec.rb
 - spec/element/after_spec.rb
 - spec/element/animations_spec.rb
@@ -93,37 +87,39 @@ files:
 - spec/element/traversing_spec.rb
 - spec/element_spec.rb
 - spec/event_spec.rb
+- spec/fixtures/simple.txt
+- spec/fixtures/user.json
 - spec/http_spec.rb
-- spec/jquery.js
+- spec/jquery/index.html
+- spec/jquery/jquery.js
+- spec/kernel_spec.rb
 - spec/spec_helper.rb
-- spec/zepto.js
+- spec/zepto/index.html
+- spec/zepto/zepto.js
 homepage: http://opalrb.org
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.1.9
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Opal access to jquery
 test_files:
-- spec/data/simple.txt
-- spec/data/user.json
 - spec/document_spec.rb
 - spec/element/after_spec.rb
 - spec/element/animations_spec.rb
@@ -142,7 +138,12 @@ test_files:
 - spec/element/traversing_spec.rb
 - spec/element_spec.rb
 - spec/event_spec.rb
+- spec/fixtures/simple.txt
+- spec/fixtures/user.json
 - spec/http_spec.rb
-- spec/jquery.js
+- spec/jquery/index.html
+- spec/jquery/jquery.js
+- spec/kernel_spec.rb
 - spec/spec_helper.rb
-- spec/zepto.js
+- spec/zepto/index.html
+- spec/zepto/zepto.js