js2 0.0.10 → 0.1.1

data/lib/js2/test/selenium.rb

@@ -1,119 +0,0 @@
-begin
-require 'rubygems'
-gem "selenium-client", ">=1.2.16"
-require "selenium/client"
-require "yaml"
-require "json"
-
-
-class JS2::Test::Selenium < Selenium::Client::Driver
-  attr_accessor :reference_dir, :child_selector
-
-  RESET_SEL_MARKER = "if (window.JS2) { window.USE_SEL_MARKER = window.JS2.SEL_MARKER; }"
-
-  class << self
-
-    def logger
-      return @logger || nil
-    end
-
-    def logger= (a_logger)
-      @logger = a_logger
-    end
-
-    def connect (config_file, env = nil)
-      config = YAML.load_file(config_file)
-      config = config[env] if env
-
-      reference_dir = config['reference_dir'] || './spec/js2refs'
-      config = config['selenium']
-      ret =  self.new( :host    => config['host']    || 'localhost',
-                       :port    => config['port']    || 4444,
-                       :browser => config['browser'] || '*firefox',
-                       :url     => config['url']     || 'http://www.factual.com',
-
-                       :timeout_in_second         => config[:timeout] || 60,
-                       :highlight_located_element => config['highlight'] || false,
-                       :javascript_framework      => config['framework'] || 'jquery' )
-
-      # hack to get an instance var in.
-      ret.reference_dir = reference_dir
-      ret.child_selector = nil
-      return ret
-    end
-  end
-
-  def get_sel_markers ()
-    json = self.execute("JS2.SEL_MARKER.toJson()")
-    struct = JSON.parse(json)
-    puts YAML::dump(struct)
-  end
-
-  def open!(uri)
-    ret = self.open(uri)
-    self.wait_for_page
-    self.set_sel_marker!
-    return ret
-  end
-
-  def execute (js)
-    puts js
-    return self.js_eval("window.eval(#{js.to_json});")
-  end
-
-  def wait_for_html(html, timeout=15000)
-    js = %{window.document.body.innerHTML.toLowerCase().replace(/[\"\']/g, '').indexOf(#{html.to_json.downcase}) >= 0;}
-    begin
-      self.wait_for_condition(js, timeout)
-      return true
-    rescue Selenium::CommandError
-      return false
-    end
-  end
-
-  def uri 
-    return self.location.sub(%r|^https?://(.*)?/|, '/')
-  end
-
-  def get_helper (klass_name)
-    klass  = klass_name
-    ref_file = %|#{@reference_dir}/#{klass_name}.yml|
-    lookup = if File.exist? ref_file
-      YAML.load_file(ref_file)
-    else
-      Hash.new
-    end
-
-    return JS2::Test::SeleniumHelper.new(klass_name, lookup, self)
-  end
-
-  def child_scope (selector)
-    js = "if (window.JS2) { window.USE_SEL_MARKER = window.JS2.SEL_MARKER."
-    js << selector.split('>').collect { |s| "children.#{s}" }.join('.')
-    js << '};'
-    @keep_selector = js
-    self.set_sel_marker!
-    yield()
-    @keep_selector = nil
-    self.set_sel_marker!
-  end
-
-  def set_sel_marker! 
-    self.execute(@keep_selector || RESET_SEL_MARKER)
-  end
-
-  def scope(klass_name)
-    self.set_sel_marker!
-    helper = get_helper(klass_name)
-    if block_given?
-      yield(helper) 
-    else
-      return helper
-    end
-  end
-
-end
-
-rescue Exception => e
-  warn "No support for selenium"
-end

data/lib/js2/test/selenium_element.rb

@@ -1,234 +0,0 @@
-class JS2::Test::SeleniumElement 
-  attr_accessor :options
-  QUICK_WAIT_FOR = 5
-  AJAX_TIME_OUT  = 60
-  def initialize (sel, klass, key, selector = nil)
-    @sel = sel
-    @key = key
-    @klass = klass
-    @selector = selector
-  end
-
-  def log (str)
-    if JS2::Test::Selenium.logger 
-      JS2::Test::Selenium.logger.info(str)
-    end
-  end
-
-  def raw
-    ret = self.class.new(@sel, @klass, @key, @selector)
-    ret.options[:raw] = true
-    return ret
-  end
-
-  def check 
-    return execute('checked=true')
-  end
-
-  def uncheck 
-    return execute('checked=false')
-  end
-
-  def checked?
-    return execute('checked')
-  end
-
-  def execute (str)
-    wait_for_ajax
-    return @sel.execute(get_js_locator() + '.' + str)
-  end
-
-  def visible?(wait_for = nil)
-    return self.check_attribute(':visible', true, wait_for);
-  end
-
-  def sel_visible?()
-     return @sel.visible?(get_ele())
-  end
-
-  def hidden?(wait_for = nil)
-    return self.check_attribute(':visible', false, wait_for);
-  end
-
-  def find (str, idx = 0)
-    selector = "window.$(#{get_js_locator()}).find(#{str.to_json})[#{idx}]"
-    return self.class.new(@sel, @klass, @key, selector)
-  end
-
-  def filter (str, idx = 0)
-    selector = "window.$(#{get_js_locator()}).filter(#{str.to_json})[#{idx}]"
-    return self.class.new(@sel, @klass, @key, selector)
-  end
-
-  def get (idx)
-    # when jqObjects in //@+ 
-    selector = "#{get_js_locator()}[#{idx}][0]"
-    return self.class.new(@sel, @klass, @key, selector)
-  end
-
-  def [] (idx)
-    selector = "#{get_js_locator()}[#{idx}]"
-    return self.class.new(@sel, @klass, @key, selector)
-  end
-
-  def attr (attr)
-    get_ele()
-    js = %{window.$(#{get_js_locator()}).attr(#{attr.to_json});}
-    return @sel.js_eval(js)
-  end
-
-  def jq_attr (attr)
-    return @sel.execute("window.$(#{get_js_locator()}).#{attr};")
-  end
-
-  def check_attribute (attr, val, wait_for = nil)
-    wait_for ||= QUICK_WAIT_FOR
-    get_ele()
-    js = %{window.$(#{get_js_locator()}).is('#{attr}') == #{val.to_json};}
-    begin
-      log "Waiting for #{@key}.#{attr} to be #{val.to_json}... Waiting #{wait_for} secs."
-      @sel.wait_for_condition(js, wait_for)
-    rescue Selenium::CommandError
-      return false
-    end
-
-    return true
-  end
-
-  def containsp? (str, timeout=QUICK_WAIT_FOR)
-    wait_for_ajax
-    js = %{window.$(#{get_js_locator()}).html().toLowerCase().replace(/[\"\']/g, '').indexOf(#{str.to_json.downcase}) >= 0;}
-    begin
-      @sel.wait_for_condition(js, timeout)
-      return true
-    rescue Selenium::CommandError
-      return false
-    end
-  end
-
-  def contains? (str,timeout=QUICK_WAIT_FOR)
-    wait_for_ajax
-    js = %{window.$(#{get_js_locator()}).html().indexOf(#{str.to_json}) >= 0;}
-    begin
-      @sel.wait_for_condition(js, timeout)
-      return true
-    rescue Selenium::CommandError
-      return false
-    end
-  end
-
-  def click (options = {})
-    @sel.click(get_ele(), options)
-  end
-
-  def text 
-    return @sel.text(get_ele())
-  end
-
-  def get_value
-    return @sel.get_value(get_ele())
-  end
-
-  def click! (options = {})
-    @sel.click(get_ele(), options)
-    @sel.wait_for_page
-  end
-
-  def mouse_up ()
-    trigger("LEFT_MOUSE_UP")
-  end
-
-  def mouse_down ()
-    trigger("LEFT_MOUSE_DOWN")
-  end
-
-  def mouse_over
-    @sel.mouse_over(get_ele())
-  end
-
-  def mouse_out
-    @sel.mouse_out(get_ele())
-  end
-
-  def key_down(value)
-    @sel.key_down(get_ele(), value)
-  end
-
-  def type (*params)
-    elem = get_ele()
-    @sel.type(elem, *params)
-    @sel.fire_event(elem, 'blur')
-  end
-
-  def select(params)
-    elem = get_ele()
-    @sel.select(elem, params)
-    @sel.fire_event(elem, 'blur')
-  end
-
-  def html ()
-    wait_for_ajax
-    js = get_js_locator()
-    return @sel.js_eval("#{js}.innerHTML;")
-  end
-
-  private
-
-  def get_locator
-    js = get_js_locator()
-    dom_locator = "dom=#{js};"
-    return dom_locator
-  end
-
-  def get_ele
-    real_locator = get_locator()
-    wait_for_ele()
-
-    return real_locator
-  end
-
-  def get_js_locator
-    if @selector
-      return @selector
-    end
-
-    filtered_locator = @key.to_s
-    int              = ''
-
-    if m = filtered_locator.match(/([^\[\]]+)(\[([^\]]*)\])/)
-      log "filtered: #{filtered_locator} #{m.inspect}"
-      filtered_locator = m[1]
-      int = ', ' + m[3] if m[3]
-    end
-
-    funct   = 'getVal'
-    get_val = "window.USE_SEL_MARKER.#{funct}('#{@klass}', '#{filtered_locator}'#{int})"
-
-    return get_val
-  end
-
-  def wait_for_ele ()
-    real_locator = get_locator
-    puts "waiting for #{real_locator}"
-    wait_for_ajax
-    @sel.wait_for_condition real_locator, QUICK_WAIT_FOR
-    puts "found #{real_locator}"
-  end
-
-  def wait_for_ajax
-    @sel.wait_for_condition('selenium.browserbot.getCurrentWindow().jQuery.active == 0', AJAX_TIME_OUT)
-  end
-
-  def trigger (event)
-    get_ele()
-    @sel.execute("window.$(#{get_js_locator}).trigger(JS2.SEL_EVENTS.#{event})")
-  end
-
-  def method_missing (method, *arg)
-    if @sel.respond_to?(method)
-      return @sel.send(method, get_js_locator, *arg)
-    else
-      raise "Method missing: #{method}"
-    end
-  end
-end

data/lib/js2/test/selenium_helper.rb

@@ -1,27 +0,0 @@
-class JS2::Test::SeleniumHelper
-  attr_accessor :klass, :lookup
-
-  def initialize (klass, lookup, sel)
-    @klass  = klass
-    @lookup = lookup
-    @sel    = sel
-    @all_eles = Hash.new
-  end
-
-  def [] (key, tail = nil)
-    key = key.to_s
-
-    return @all_eles[key] if @all_eles[key] 
-
-    # TODO: support inheritence
-    #raise "invalid key #{key}" unless @lookup[key]
-
-    return @all_eles[key] = JS2::Test::SeleniumElement.new(@sel, @klass, key, tail)
-  end
-
-  def type_form (params = {})
-    params.each_pair do |k,v|
-      self[k].type(v)
-    end
-  end
-end

data/lib/js2/tree.rb

@@ -1,351 +0,0 @@
-class JS2::Node < Array
-  attr_accessor :start_idx, :static
-  SEL = JS2::SelDecorator.new
-
-  def initialize (start_idx, string, static = false)
-    @static      = static
-    @stack       = []
-    @start_idx   = start_idx
-    @current_idx = @start_idx
-    @string      = string
-  end
-
-  def set_child (node)
-    len = node.start_idx - @current_idx
-    if len > 0
-      self << @string[@current_idx, len]
-    end
-
-    self << node
-  end
-
-
-  def stop_child (idx)
-    @current_idx = idx
-  end
-
-  def to_s 
-    ret = []
-    last_idx = self.length - 1
-
-    self.each_with_index do |s, i|
-      if i == 0
-        ret << self.first_string(s)
-      elsif i == last_idx
-        ret << self.last_string(s)
-      else
-        ret << s.to_s
-      end
-    end
-
-    if last_idx == 0
-      ret << self.last_string('')
-    end
-
-    return ret.join('')
-  end
-
-  def first_string (s)
-    return s.to_s
-  end
-
-  def last_string (s)
-    return s.to_s
-  end
-
-  def mark (idx)
-    len = idx - @current_idx
-    if len > 0
-      self << @string[@current_idx, len]
-    end
-
-    @current_idx = idx
-  end
-
-  def stop (idx)
-    len = idx - @current_idx 
-    if len > 0
-      self << @string[@current_idx, len]
-    end
-    self.setup!
-  end
-
-  def setup!
-  end
-
-  def reset
-  end
-end
-
-class JS2::Stuff < JS2::Node
-  def to_s
-    str = super
-    str = SEL.translate(str, nil, false)
-    return str
-  end
-end
-
-class JS2::Class < JS2::Node
-  REGEX = /^(\s*class|module)\s+([\w\.]+)\s+(extends\s+([\w\.]+))?\s*\{(.*)/m
-  attr_accessor :name, :extends
-
-  def setup!
-    m = self[0].match(REGEX)
-    @name    = m[2]
-    @extends = m[4]
-    @start   = m[5]
-  end
-
-  def createName 
-    return 'createClass'
-  end
-
-  def first_string (s)
-    extends = nil
-    if @extends
-      extends = "#{@name}.oo('extends', #{@extends});"
-    end
-
-    
-    return %|JS2.OO.#{createName}("#{@name}"); #{extends} (function (K,Package) {var self=K; var _super=JS2.OO['super']; #{@start}|
-  end
-
-  def last_string (s)
-    pkg = @name.split(/\./)
-    pkg.pop()
-
-    if pkg.empty?
-      pkg = 'null'
-    else
-      pkg = pkg.join('.')
-    end
-
-    #pkg = pkg.length > 0 ? pkg : 'null' 
-    return s.to_s + ")(#{@name}, #{pkg});"
-  end
-
-  def to_s
-    str = super
-    str = SEL.translate(str, @name, true)
-    return str
-  end
-end
-
-class JS2::Property < JS2::Node
-  REGEX = /(\s*)property(\s+)([\w+,\s]+\w)(\s*)/
-  def setup!
-    m = first.match(REGEX)
-    @space     = m[1]
-    @mid_space = m[2]
-    @list      = m[3].split(/,/).collect { |i| i.strip }
-    @end_space = m[4]
-  end
-
-  def to_s
-    return %|#{@space}K.oo('property',#{@mid_space}[ #{@list.collect { |i| "'#{i}'" }.join(',')} ]);|
-  end
-end
-
-class JS2::Accessor < JS2::Node
-  REGEX = /(\s*)accessor(\s+)([\w+,\s]+\w)(\s*)/
-  def setup!
-    m = first.match(REGEX)
-    @space     = m[1]
-    @mid_space = m[2]
-    @list      = m[3].split(/,/).collect { |i| i.strip }
-    @end_space = m[4]
-  end
-
-  def to_s
-    return %|#{@space}K.oo('accessor',#{@mid_space}[ #{@list.collect { |i| "'#{i}'" }.join(',')} ]);|
-  end
-
-end
-
-
-class JS2::Foreach < JS2::Node
-  #                   start     var           iterator           array
-  REGEX = /(\s*)foreach\s*\(\s*var\s*([\$\w]+)(\s*:\s*([\$\w]))?\s*in\s*([^\s]+)\s*\)/
-  attr_accessor :iterator, :item, :array
-  @@inc = 0
-
-  def setup!
-    m = first.match(REGEX)
-    @start    = m[1]
-    @item     = m[2]
-    @iterator = m[4]
-    @array    = m[5]
-  end
-
-  def first_string (s)
-    it = iterator
-
-    unless iterator
-      it = 'it' + @@inc.to_s
-      @@inc += 1
-    end
-
-    len = it + '__len'
-    arr = it + '__arr'
-
-    return %(#{@start}for (var #{it}=0,#{@item},#{arr}=#{@array},#{len}=#{arr}.length; (#{@item}=#{arr}[#{it}]) || #{it}<#{len}; #{it}++))
-  end
-
-  def self.reset
-    @@inc = 0
-  end
-
-end
-
-class JS2::Module < JS2::Class
-  def createName
-    return 'createModule'
-  end
-end
-
-class JS2::Private < JS2::Node
-  def to_s
-    return first.sub(/private/m, '// private')
-  end
-end
-
-
-
-class JS2::Include < JS2::Node
-  def first_string (s)
-    return s.sub(/include\s*/, "K.oo('include', ").sub(/;$/, ');');
-  end
-end
-
-class JS2::Member < JS2::Node
-  def first_string (s)
-    method = 'member'
-
-    if s.match(/^(\s*)(static)\s*/)
-      method = 'staticMember'
-      s = s.sub(/static\s*/, '')
-    end
-
-    return s.sub(/var\s*([\$\w]+)/) { "K.oo('#{method}', '" + $1 + "'" }.sub(/;$/, ');').sub(/\s*=/, ', ');
-  end
-end
-
-class JS2::Curry < JS2::Node
-  REGEX       = %r|^curry\s*([^\{]*)?\{(.*)$|m
-  REGEX_WITH  = %r|with\s+\(([^)]*)\)|
-  REGEX_ARGS  = %r|^\s*\(([^)]*)\)|
-
-  def setup!
-    m = first.match(REGEX)
-    @decl = m[1].strip
-    @stop = m[2]
-
-    @args   = ''
-    @in_scoped = ''
-    @scoped    = ''
-
-    if m = @decl.match(REGEX_WITH)
-      in_scoped = m[1].split(',').collect { |v| v.strip }
-      scoped    = in_scoped.collect { |v| v == 'this' ? 'self' : v }
-      if in_scoped.length
-        @scoped =  scoped.join(', ')
-        @in_scoped = in_scoped.join(', ')
-      end
-    end
-
-    if m = @decl.match(%r|^\s*\(([^)]*)\)|)
-      @args = m[1].strip
-    end
-  end
-
-  def first_string (s)
-    return %|(function (#{@scoped}) { return function (#{@args}) {#{@stop}|
-  end
-
-  def last_string (s) 
-    return s + %|})(#{@in_scoped})|
-  end
-end
-
-class JS2::Method < JS2::Node
-  REGEX = /^(\s*)(static\s+)?function\s+([\$\w\.]+)\s*\(([^)]*)\)\s*\{(.*)/m
-  attr_accessor :name, :args
-
-  def setup!
-    m = self[0].match(REGEX)
-    @space  = m[1]
-    @static = m[2]
-    @name   = m[3]
-    @args   = m[4]
-    @start  = m[5]
-  end
-
-  def first_string (s)
-    m = static ? 'staticMember' : 'method'
-    return %|#{@space}K.oo('#{m}', "#{@name}", function (#{args}) {#{@start}|
-  end
-
-  def last_string (s)
-    return %|#{s});|
-  end
-end
-
-class JS2::Ignore < JS2::Node
-  def to_s
-    return ''
-  end
-end
-
-
-
-class JS2::ParserHelper
-  attr_accessor :filename, :classes, :extra
-
-  TYPES = {
-    :CLASS    => JS2::Class,
-    :FOREACH  => JS2::Foreach,
-    :INCLUDE  => JS2::Include,
-    :METHOD   => JS2::Method,
-    :MEMBER   => JS2::Member,
-    :MODULE   => JS2::Module,
-    :STUFF    => JS2::Stuff,
-    :STATIC   => JS2::Ignore,
-    :PRIVATE  => JS2::Private,
-    :CURRY    => JS2::Curry,
-    :PROPERTY => JS2::Property,
-    :ACCESSOR => JS2::Accessor
-  }
-
-  def initialize (code)
-    @code    = code
-    @stack   = [ JS2::Stuff.new(0, @code) ]
-    @classes = []
-    @extra   = []
-  end
-
-  def mark_node (idx)
-    @stack.last.mark(idx)
-  end
-
-  def start_node (type, start_idx, static = false) 
-    klass    = TYPES[type] || JS2::Node
-    new_node = klass.new(start_idx, @code, static)
-    if type == :CLASS || type == :MODULE
-      @classes.push(new_node)
-    end
-
-    @stack.last.set_child(new_node) if @stack.last
-    @stack.push << new_node
-  end
-
-  def stop_node (stop_idx) 
-    last = @stack.pop
-    last.stop(stop_idx) if last
-    @stack.last.stop_child(stop_idx) if @stack.last
-  end
-
-  def to_s 
-    return @stack.collect { |i| i.to_s }.join('') + (extra.empty? ?  '' : ("\n" + extra.join("\n")))
-  end
-end
-