js2 0.0.8 → 0.0.9

data/lib/js2/process/universe.rb

@@ -1,89 +0,0 @@
-class JS2::Process::Universe 
-  attr_accessor :compilations
-
-  def initialize 
-    @class_lookup = Hash.new
-    @haml_lookup  = Hash.new
-    @node_containers = Array.new
-    @mod_lookup      = Hash.new
-
-    @compilations = Hash.new
-  end
-
-  def add_nodes (nodes)
-    nodes.select { |n| n.is_a? JS2::AST::ClassNode }.each do |k|
-      @class_lookup[k.name] = k
-    end
-
-    nodes.select { |n| n.is_a? JS2::AST::ModuleNode }.each do |k|
-      @class_lookup[k.name] = k
-    end
-
-    @node_containers << nodes
-  end
-
-  def add_yml (yml, filename)
-    yml.each_pair do |klass_name, config|
-      template = config['template']
-      next unless template
-
-      str = "  function getTemplate () { return #{template.to_json} }"
-      node = JS2::AST::MethodNode.new(filename, 0, str)
-      k = @class_lookup[klass_name]
-      k.members << node
-      k.mem_hash['getTemplate'] = node
-
-      if config['make_compilation']
-        compilation = [ k.filename ]
-
-        if config['include']
-          compilation += config['include'].collect { |name| @class_lookup[name].filename }
-        end
-
-        template.each do |t|
-          klass_name = t['class']
-          klass = @class_lookup[klass_name]
-          compilation << klass.filename
-        end
-        @compilations[k.filename] = compilation
-      end
-    end
-  end
-
-  def node_containers 
-    return @node_containers
-  end
-
-  def add_haml_hash (hash)
-    hash.each_pair do |name, haml_hash|
-      @haml_lookup[name] ||= JS2::AST::HamlNode.new
-      haml = @haml_lookup[name]
-
-      haml_hash.each_pair do |k,v|
-        haml[k] = v
-      end
-    end
-  end
-
-  def finalize! ()
-    @class_lookup.values.each do |k|
-      # set parents
-      k.parent = @class_lookup[k.extends] if k.extends
-      included_mods = []
-      k.includes.each do |mod_node|
-        m = @class_lookup[mod_node.name] 
-        included_mods << m if m
-      end
-
-      k.included_mods = included_mods
-
-      # set haml
-      k.haml = @haml_lookup[k.name] if @haml_lookup[k.name]
-    end
-
-    @class_lookup.values.each do |k|
-      k.finalize!
-    end
-  end
-
-end

data/lib/js2/test/selenium.rb

@@ -1,109 +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 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)
-    wait_for_ajax
-    js = %{window.$(#{get_js_locator()}).html().toLowerCase().indexOf(#{str.to_json.downcase}) >= 0;}
-    begin
-      @sel.wait_for_condition(js, QUICK_WAIT_FOR)
-      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