module Ruby2JS::Filter::JQuery

Public Class Methods

new(*args) click to toggle source
Calls superclass method
# File lib/ruby2js/filter/jquery.rb, line 68
def initialize(*args)
  @react = nil
  super
end

Public Instance Methods

on_block(node) click to toggle source

Example conversion:

before:
 $$.post ... do ... end
 (block (send (gvar :$$) :post ...) (args) (...))
after:
 $$.post ..., proc { ... }, :json
 (send (gvar :$$) :post ... 
   (block (send nil :proc) (args) (...)) (:sym :json))
Calls superclass method
# File lib/ruby2js/filter/jquery.rb, line 177
def on_block(node)
  call = node.children.first
  return super unless call.children.first == s(:gvar, :$$)
  return super unless call.children[1] == :post
  return super unless call.children.length <= 4
  children = call.children.dup
  children << s(:str, '') if children.length <= 2
  children << s(:hash) if children.length <= 3
  children << s(:block, s(:send, nil, :proc), *node.children[1..-1])
  children << s(:sym, :json)
  process call.updated nil, children
end
on_gvar(node) click to toggle source

map $$ to $

Calls superclass method
# File lib/ruby2js/filter/jquery.rb, line 74
def on_gvar(node)
  if node.children[0] == :$$
    node.updated nil, ['$']
  else
    super
  end
end
on_send(node) click to toggle source
Calls superclass method
# File lib/ruby2js/filter/jquery.rb, line 82
def on_send(node)
  if [:call, :[]].include? node.children[1] and node.children.first
    # map $$.call(..), $$.(..), and $$[...] to $(...)
    target = process(node.children.first)
    if target.type == :gvar and target.children == ['$']
      s(:send, nil, '$', *process_all(node.children[2..-1]))
    else
      super
    end

  elsif node.children[1] == :to_a
    process S(:call, node.children[0], :toArray, *node.children[2..-1])

  elsif node.children[1] == :~ and not @react
    # map ~expression.method to $(expression).method

    if node.children[0] and node.children[0].type == :op_asgn
      asgn = node.children[0]
      if asgn.children[0] and asgn.children[0].type == :send
        inner = asgn.children[0]
        return on_send s(:send, s(:send, inner.children[0],
          (inner.children[1].to_s+'=').to_sym,
          s(:send, s(:send, s(:send, inner.children[0], :~),
          *inner.children[1..-1]), *asgn.children[1..-1])), :~)
      else
        return on_send asgn.updated nil, [s(:send, asgn.children[0], :~),
          *asgn.children[1..-1]]
      end
    end

    # See http://api.jquery.com/category/properties/
    props = :context, :jquery, :browser, :fx, :support, :length, :selector
    domprops = %w(checked disabled readonly readOnly required)

    stopProps = false
    rewrite_tilda = proc do |tnode|
      # Example conversion:
      #   before:
      #    (send (send (send (send nil :a) :b) :c) :~)
      #   after:
      #    (send (send (send nil "$" (send nil :a)) :b) :c)
      if tnode.type == :send and tnode.children[0]
        stopProps = true if tnode.children[1] == :[]
        if tnode.children[1] == :~ and tnode.children[0].children[1] == :~
          # consecutive tildes
          if tnode.children[0].children[0].children[1] == :~
            result = tnode.children[0].children[0].children[0]
          else
            result = s(:attr, tnode.children[0].children[0], :~)
          end
          s(:attr, s(:attr, process(result), :~), :~)
        else
          # possible getter/setter
          method = tnode.children[1]
          method = method.to_s.chomp('=') if method =~ /=$/
          method = :each! if method == :each
          rewrite = [rewrite_tilda[tnode.children[0]], 
            method, *tnode.children[2..-1]]
          if stopProps or props.include? tnode.children[1]
            rewrite[1] = tnode.children[1]
            tnode.updated nil, rewrite
          elsif domprops.include? method.to_s
            method = :readOnly if method.to_s == 'readonly'
            s(:send, rewrite[0], :prop, s(:sym, method), *rewrite[2..-1]) 
          else
            s(:send, *rewrite)
          end
        end
      elsif tnode.type == :block
        # method call with a block parameter
        tnode.updated nil, [rewrite_tilda[tnode.children[0]],
          *tnode.children[1..-1]]
      elsif tnode.type == :array
        # innermost expression is an array
        s(:send, nil, '$', *tnode)
      else
        # innermost expression is a scalar
        s(:send, nil, '$', tnode)
      end
    end

    process rewrite_tilda[node].children[0]
  else
    super
  end
end