opal-jquery 0.0.6 → 0.0.7

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## 0.0.7 2013-02-20
+
+*   Add Element#method_missing which forwards missing calls to try and call
+    method as a native jquery function/plugin.
+
+*   Depreceate Document finder methods (Document.find, Document[]). The finder
+    methods on Element now replace them. Updated specs to suit.

data/Gemfile

@@ -1,8 +1,5 @@
-source :rubygems
+source "https://rubygems.org"
 gemspec
 
 gem 'rake'
-gem 'sprockets'
-
-gem 'opal', '~> 0.3.36'
-gem 'opal-spec', '~> 0.2.10'
+gem 'opal-spec', '~> 0.2.12'

data/lib/assets/javascripts/opal/jquery/document.rb

@@ -1,28 +1,4 @@
 module Document
-  def self.[](selector)
-    `$(#{selector})`
-  end
-
-  def self.find(selector)
-    self[selector]
-  end
-
-  def self.id(id)
-    %x{
-      var el = document.getElementById(id);
-
-      if (!el) {
-        return nil;
-      }
-
-      return $(el);
-    }
-  end
-
-  def self.parse(str)
-    `$(str)`
-  end
-
   def self.ready?(&block)
     %x{
       if (block === nil) {

data/lib/assets/javascripts/opal/jquery/element.rb

@@ -2,11 +2,19 @@
 # native dom elements.
 class Element < `jQuery`
   def self.find(selector)
-    `$(selector)`
+    `$(#{selector})`
   end
 
   def self.id(id)
-    Document.id(id)
+    %x{
+      var el = document.getElementById(id);
+
+      if (!el) {
+        return nil;
+      }
+
+      return $(el);
+    }
   end
 
   def self.new(tag = 'div')
@@ -17,59 +25,50 @@ class Element < `jQuery`
     `$(str)`
   end
 
-  def [](name)
-    `#{self}.attr(name) || ""`
+  def self.expose(*methods)
+    %x{
+      for (var i = 0, length = methods.length, method; i < length; i++) {
+        method = methods[i];
+        #{self}.prototype['$' + method] = #{self}.prototype[method];
+      }
+
+      return nil;
+    }
   end
 
-  alias_native :[]=, :attr
-
-  # Add the given content to inside each element in the receiver. The
-  # content may be a HTML string or a `DOM` instance. The inserted
-  # content is added to the end of the receiver.
-  #
-  # @example Given HTML String
-  #
-  #   DOM.find('ul').append '<li>list content</li>'
-  #
-  # @example Given an existing DOM node
-  #
-  #   DOM.id('checkout') << Dom.id('total-price-label')
-  #
-  # @param [String, DOM] content HTML string or DOM content
-  # @return [DOM] returns receiver
-  alias_native :<<, :append
+  expose :after, :before, :parent, :parents, :prepend, :prev, :remove
+  expose :hide, :show, :toggle, :children, :blur, :closest, :data
+  expose :focus, :find, :next, :siblings, :text, :trigger, :append
 
+  alias_native :[]=, :attr
   alias_native :add_class, :addClass
+  alias_native :append_to, :appendTo
+  alias_native :has_class?, :hasClass
+  alias_native :html=, :html
+  alias_native :remove_attr, :removeAttr
+  alias_native :remove_class, :removeClass
+  alias_native :text=, :text
+  alias_native :toggle_class, :toggleClass
+  alias_native :value=, :val
 
-  # Add the given content after each element in the receiver. The given
-  # content may be a HTML string, or a `DOM` instance.
-  #
-  # @example Given HTML String
-  #
-  #   DOM.find('.label').after '<p>Content after label</>'
-  #
-  # @example Given existing DOM nodes
-  #
-  #   DOM.find('.price').after DOM.id('checkout-link')
-  #
-  # @param [String, DOM] content HTML string or dom content
-  # @return [DOM] returns self
-  alias_native :after, :after
-
-  alias append <<
+  # Missing methods are assumed to be jquery plugins. These are called by
+  # the given symbol name.
+  def method_missing(symbol, *args, &block)
+    %x{
+      if (#{self}[#{symbol}]) {
+        return #{self}[#{symbol}].apply(#{self}, args);
+      }
+    }
+    
+    super
+  end
 
-  # Appends the elements in #{self} object into the target element. #{self}
-  # method is the reverse of using `#append` on the target with #{self}
-  # instance as the argument.
-  #
-  # @example
-  #
-  #   DOM.parse('<p>Hello</p>').append_to DOM.id('foo')
-  #
-  # @param [DOM] target the target to insert into
-  # @return [DOM] returns the receiver
-  alias_native :append_to, :appendTo
+  def [](name)
+    `#{self}.attr(name) || ""`
+  end
 
+  alias << append
+  
   def append_to_body
     `#{self}.appendTo(document.body)`
   end
@@ -106,33 +105,6 @@ class Element < `jQuery`
     }
   end
 
-  # Insert the given content into the DOM before each element in #{self}
-  # collection. The content may be a raw HTML string or a `DOM`
-  # instance containing elements.
-  #
-  # @example
-  #
-  #   # Given a string
-  #   DOM('.foo').before '<p class="title"></p>'
-  #
-  #   # Using an existing element
-  #   DOM('.bar').before DOM('#other-title')
-  #
-  # @param [DOM, String] content the content to insert before
-  # @return [DOM] returns the receiver
-  alias_native :before, :before
-
-  # Returns a new collection containing the immediate children of each
-  # element in #{self} collection. The result may be empty if no children
-  # are present.
-  #
-  # @example
-  #
-  #   DOM('#foo').children  # => DOM instance
-  #
-  # @return [DOM] returns new DOM collection
-  alias_native :children, :children
-
   # 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.
@@ -146,12 +118,7 @@ class Element < `jQuery`
   def class_name
     %x{
       var first = #{self}[0];
-
-      if (!first) {
-        return "";
-      }
-
-      return first.className || "";
+      return (first && first.className) || "";
     }
   end
 
@@ -226,12 +193,6 @@ class Element < `jQuery`
     } 
   end
 
-  alias_native :blur, :blur
-
-  alias_native :closest, :closest
-
-  alias_native :data, :data
-
   # Yields each element in #{self} collection in turn. The yielded element
   # is wrapped as a `DOM` instance.
   #
@@ -271,42 +232,18 @@ class Element < `jQuery`
     map {|el| el }
   end
 
-  # Find all the elements that match the given `selector` within the
-  # scope of elements in #{self} given collection. Might return an empty
-  # collection if no elements match.
-  #
-  # @example
-  #
-  #   form = DOM('#login-form')
-  #   form.find 'input, select'
-  #
-  # @param [String] selector the selector to match elements against
-  # @return [DOM] returns new collection
-  alias_native :find, :find
-
   def first
     `#{self}.length ? #{self}.first() : nil`
   end
 
-  alias_native :focus, :focus
-
-  alias_native :has_class?, :hasClass
-
   def html
     `#{self}.html() || ""`
   end
 
-  alias_native :html=, :html
-
   def id
     %x{
       var first = #{self}[0];
-
-      if (!first) {
-        return "";
-      }
-
-      return first.id || "";
+      return (first && first.id) || "";
     }
   end
 
@@ -344,67 +281,20 @@ class Element < `jQuery`
     `#{self}.length`
   end
 
-  alias_native :next, :next
-
-  alias_native :siblings, :siblings
-
-  def on(name, selector = nil, &handler)
-    %x{
-      if (selector === nil) {
-        #{self}.on(name, handler);
-      }
-      else {
-        #{self}.on(name, selector, handler);
-      }
-
-      return handler;
-    }
+  def on(name, sel = nil, &block)
+    `sel === nil ? #{self}.on(name, block) : #{self}.on(name, sel, block)`
+    block
   end
 
-  def off(name, selector = nil, &handler)
-    %x{
-      if (selector === nil) {
-        return #{self}.off(name, handler);
-      }
-      else {
-        return #{self}.off(name, selector, handler);
-      }
-    }
+  def off(name, sel = nil, &block)
+    `sel === nil ? #{self}.off(name, block) : #{self}.off(name, sel, block)`
   end
 
-  alias_native :remove_attr, :removeAttr
-
-  alias_native :parent, :parent
-
-  alias_native :parents, :parents
-
-  alias_native :prepend, :prepend
-
-  alias_native :prev, :prev
-
-  alias_native :remove, :remove
-
-  alias_native :remove_class, :removeClass
-
   alias size length
 
   alias succ next
 
-  alias_native :text, :text
-  alias_native :text=, :text
-
-  alias_native :toggle_class, :toggleClass
-
-  alias_native :trigger, :trigger
-
   def value
     `#{self}.val() || ""`
   end
-
-  alias_native :value=, :val
-
-  # display functions
-  alias_native :hide, :hide
-  alias_native :show, :show
-  alias_native :toggle, :toggle
 end

data/lib/opal/jquery/version.rb

@@ -1,5 +1,5 @@
 module Opal
   module JQuery
-    VERSION = '0.0.6'
+    VERSION = '0.0.7'
   end
 end

data/opal-jquery.gemspec

@@ -14,4 +14,6 @@ Gem::Specification.new do |s|
   s.executables    = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.test_files     = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths  = ['lib']
+
+  s.add_runtime_dependency 'opal', '~> 0.3.39'
 end

data/spec/document_spec.rb

@@ -1,79 +1,6 @@
 require "spec_helper"
 
 describe Document 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
-      Document['#foo'].class_name.should == "bar"
-      Document['#foo'].size.should == 1
-    end
-
-    it "should be able to match any valid CSS selector" do
-      Document['.woosh'].should be_kind_of(Element)
-      Document['.woosh'].size.should == 2
-    end
-
-    it "should return an empty Elements instance when not matching any elements" do
-      dom = Document['.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 = Document['<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 = Document.find '.find-foo'
-      foo.should be_kind_of(Element)
-      foo.length.should == 2
-
-      bar = Document.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 = Document.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
-      Document.id('foo').should be_kind_of(Element)
-      Document.id('foo').id.should == 'foo'
-    end
-
-    it "should return nil if no element could be found" do
-      Document.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 = Document.parse '<div id="foo" class="bar"></div>'
-      foo.id.should == 'foo'
-      foo.class_name.should == 'bar'
-    end
-  end
-
   describe '.title and .title=' do
     it 'sets/gets the page title' do
       current = Document.title

data/spec/element/after_spec.rb

@@ -9,17 +9,17 @@ describe "Element#after" do
   HTML
 
   it "should insert the given html string after each element" do
-    el = Document['.after-spec-first']
+    el = Element.find('.after-spec-first')
     el.size.should == 2
 
     el.after '<p class="woosh"></p>'
 
-    Document.id('foo').next.class_name.should == "woosh"
-    Document.id('bar').next.class_name.should == "woosh"
+    Element.find('#foo').next.class_name.should == "woosh"
+    Element.find('#bar').next.class_name.should == "woosh"
   end
 
   it "should insert the given DOM element after this element" do
-    Document.id('baz').after Document.id('some-header')
-    Document.id('baz').next.id.should == "some-header"
+    Element.find('#baz').after Element.find('#some-header')
+    Element.find('#baz').next.id.should == "some-header"
   end
 end