RubyGems - superchris-rubyjs - Versions diffs - 0.8.2 - Mend

superchris-rubyjs 0.8.2

Files changed (86) hide show

data/README +131 -0
data/Rakefile +65 -0
data/bin/rubyjs +144 -0
data/rubyjs.gemspec +112 -0
data/src/rubyjs.rb +3 -0
data/src/rubyjs/code_generator.rb +474 -0
data/src/rubyjs/compiler.rb +2061 -0
data/src/rubyjs/debug_name_generator.rb +95 -0
data/src/rubyjs/encoder.rb +171 -0
data/src/rubyjs/eval_into.rb +59 -0
data/src/rubyjs/lib/core.rb +1016 -0
data/src/rubyjs/lib/dom_element.rb +66 -0
data/src/rubyjs/lib/json.rb +101 -0
data/src/rubyjs/lib/microunit.rb +188 -0
data/src/rubyjs/model.rb +293 -0
data/src/rubyjs/name_generator.rb +71 -0
data/src/rwt/AbsolutePanel.rb +161 -0
data/src/rwt/DOM.Konqueror.rb +89 -0
data/src/rwt/DOM.Opera.rb +65 -0
data/src/rwt/DOM.rb +1044 -0
data/src/rwt/Event.Opera.rb +35 -0
data/src/rwt/Event.rb +429 -0
data/src/rwt/HTTPRequest.IE6.rb +5 -0
data/src/rwt/HTTPRequest.rb +74 -0
data/src/rwt/Label.rb +164 -0
data/src/rwt/Panel.rb +90 -0
data/src/rwt/RootPanel.rb +16 -0
data/src/rwt/UIObject.rb +495 -0
data/src/rwt/Widget.rb +193 -0
data/src/rwt/ported-from/AbsolutePanel.java +158 -0
data/src/rwt/ported-from/DOM.java +571 -0
data/src/rwt/ported-from/DOMImpl.java +426 -0
data/src/rwt/ported-from/DOMImplOpera.java +82 -0
data/src/rwt/ported-from/DOMImplStandard.java +234 -0
data/src/rwt/ported-from/HTTPRequest.java +81 -0
data/src/rwt/ported-from/HTTPRequestImpl.java +103 -0
data/src/rwt/ported-from/Label.java +163 -0
data/src/rwt/ported-from/Panel.java +99 -0
data/src/rwt/ported-from/UIObject.java +614 -0
data/src/rwt/ported-from/Widget.java +221 -0
data/test/benchmark/bm_vm1_block.rb +15 -0
data/test/benchmark/bm_vm1_const.rb +13 -0
data/test/benchmark/bm_vm1_ensure.rb +15 -0
data/test/benchmark/common.rb +5 -0
data/test/benchmark/params.yaml +7 -0
data/test/common.Browser.rb +13 -0
data/test/common.rb +8 -0
data/test/gen_browser_test_suite.rb +129 -0
data/test/gen_test_suite.rb +41 -0
data/test/run_benchs.rb +58 -0
data/test/run_tests.rb +22 -0
data/test/test_args.rb +24 -0
data/test/test_array.rb +22 -0
data/test/test_case.rb +35 -0
data/test/test_class.rb +55 -0
data/test/test_eql.rb +9 -0
data/test/test_exception.rb +61 -0
data/test/test_expr.rb +12 -0
data/test/test_hash.rb +29 -0
data/test/test_hot_ruby.rb +146 -0
data/test/test_if.rb +28 -0
data/test/test_insertion_sort.rb +25 -0
data/test/test_inspect.rb +10 -0
data/test/test_lebewesen.rb +39 -0
data/test/test_massign.rb +66 -0
data/test/test_new.rb +12 -0
data/test/test_range.rb +70 -0
data/test/test_regexp.rb +22 -0
data/test/test_send.rb +65 -0
data/test/test_simple_output.rb +5 -0
data/test/test_splat.rb +21 -0
data/test/test_string.rb +51 -0
data/test/test_test.rb +17 -0
data/test/test_yield.rb +154 -0
data/utils/js/Makefile +9 -0
data/utils/js/RunScript.class +0 -0
data/utils/js/RunScript.java +73 -0
data/utils/js/js.jar +0 -0
data/utils/js/run.sh +3 -0
data/utils/jsc/Makefile +7 -0
data/utils/jsc/README +3 -0
data/utils/jsc/RunScript.c +93 -0
data/utils/jsc/run.sh +15 -0
data/utils/yuicompressor/README +1 -0
data/utils/yuicompressor/yuicompressor-2.2.5.jar +0 -0
metadata +157 -0

data/src/rubyjs/lib/dom_element.rb ADDED

@@ -0,0 +1,66 @@
+class DOMElement
+  def initialize(element)
+    @dom_element = element
+  end
+  def observe(event, &block)
+    element = @dom_element
+    `
+      if (#<element>.addEventListener) {
+        #<element>.addEventListener(#<event>, #<block>, false);
+      } else {
+        #<element>.attachEvent("on" + #<event>, #<block>);
+      }
+    `
+    nil
+  end
+  def [](attribute)
+    element = @dom_element
+    `return #<element>[#<attribute>]`
+  end
+  def []=(attr, value)
+    attr_name = attr.to_s
+    element = @dom_element
+    `#<element>[#<attr_name>] = #<value>;`
+    nil
+  end
+  def self.find_js_element(element)
+    `return document.getElementById(#<element>);`
+  end
+  def self.find(element)
+    dom_element = self.find_js_element(element)
+    DOMElement.new(dom_element)
+  end
+  #
+  # Gets an HTML representation (as String) of an element's children.
+  #
+  # elem::   the element whose HTML is to be retrieved
+  # return:: the HTML representation of the element's children
+  #
+  def inner_html
+    elem = @dom_element
+    `
+    var ret = #<elem>.innerHTML;
+    return (ret == null) ? #<nil> : ret;`
+  end
+  #
+  # Sets the HTML contained within an element.
+  #
+  # elem:: the element whose inner HTML is to be set
+  # html:: the new html
+  #
+  def inner_html=(html)
+    elem = @dom_element
+    `
+    #<elem>.innerHTML = #<html>;
+    return #<nil>;`
+  end
+end

data/src/rubyjs/lib/json.rb ADDED

@@ -0,0 +1,101 @@
+#
+# JSON loading/dumping
+#
+# Parser code taken from http://www.json.org/json.js
+#
+class JSON
+  class SyntaxError < RuntimeError; end
+  #
+  # Parsing happens in three stages. In the first stage, we run the text against
+  # a regular expression which looks for non-JSON characters. We are especially
+  # concerned with '()' and 'new' because they can cause invocation, and '='
+  # because it can cause mutation. But just to be safe, we will reject all
+  # unexpected characters.
+  #
+  # We split the first stage into 4 regexp operations in order to work around
+  # crippling deficiencies in IE's and Safari's regexp engines. First we replace
+  # all backslash pairs with '@' (a non-JSON character). Second, we replace all
+  # simple value tokens with ']' characters. Third, we delete all open brackets
+  # that follow a colon or comma or that begin the text. Finally, we look to see
+  # that the remaining characters are only whitespace or ']' or ',' or ':' or '{'
+  # or '}'. If that is so, then the text is safe for eval.
+  #
+  # In the second stage we use the eval function to compile the text into a
+  # JavaScript structure. The '{' operator is subject to a syntactic ambiguity
+  # in JavaScript: it can begin a block or an object literal. We wrap the text
+  # in parens to eliminate the ambiguity.
+  #
+  def self._parse(str)
+    RubyJS::inline <<-'endjs'
+      if (/^[\],:{}\s]*$/.test(#<str>.replace(/\\./g, '@').
+          replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(:?[eE][+\-]?\d+)?/g, ']').
+          replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+        return eval('(' + #<str> + ')');
+      }
+    endjs
+    raise SyntaxError, str
+  end
+  def self.load(str)
+    obj = _parse(str)
+   `
+    var conv = function(obj) {
+      if (obj==null) return #<nil>;
+      else if (obj instanceof Array) {
+        for (var i=0; i<obj.length; i++) obj[i] = conv(obj[i]);
+      }
+      else if (typeof(obj) == 'object') {
+        var nobj = #<Hash>.#<m:new>();
+        for (var i in obj) {
+          nobj.#<m:[]=>(#<nil>, conv(i), conv(obj[i]));
+        }
+        return nobj;
+      }
+      return obj;
+    };
+    return conv(#<obj>);
+   `
+  end
+  def self.dump(obj)
+    obj.to_json
+  end
+end
+class Object
+  def to_json; raise end
+end
+class Boolean
+  alias to_json to_s
+end
+class NilClass
+  def to_json; "null" end
+end
+class String
+  alias to_json inspect # FIXME?
+end
+class Number
+  alias to_json to_s
+end
+class Array
+  def to_json
+    map {|a| a.to_json}.join(",")
+  end
+end
+class Hash
+  def to_json
+    str = "{"
+    str += map {|k, v| (k.to_json + ":" + v.to_json) }.join(",")
+    str += "}"
+    str
+  end
+end

data/src/rubyjs/lib/microunit.rb ADDED

@@ -0,0 +1,188 @@
+module MicroUnit
+  class TestCase
+#    def self.reset
+#      @@test_suites = {}
+#    end
+#
+#    reset
+#    def self.inherited klass
+#      @test_suites ||= {}
+#      @test_suites[klass] = true
+#    end
+#
+#    def self.test_suites
+#      @test_suites.keys.sort_by { |ts| ts.name }
+#    end
+    attr_accessor :_assertions
+    def setup
+    end
+    def teardown
+    end
+    def _increment_assertions
+      @_assertions ||= 0
+      @_assertions += 1
+    end
+    def assert test, msg = "failed assertion (no message given)"
+      _increment_assertions
+      raise StandardError, msg unless test
+    end
+    def assert_block msg = "assert_block failed."
+      assert yield, msg
+    end
+    def assert_equal exp, act, msg = ""
+      msg += '.' unless msg.empty?
+      assert exp == act, "#{msg}\n<#{exp.inspect}> expected but was\n<#{act.inspect}>.".strip
+    end
+    def self.main
+      TestRunner.run(self)
+    rescue StandardError => error
+      puts error
+    end
+    #
+    #  def assert_in_delta exp, act, delta, msg = "Expected #{exp} to be within #{delta} of #{act}"
+    #    assert delta.to_f > (exp.to_f - act.to_f).abs, msg
+    #  end
+    #
+    #  def assert_instance_of cls, obj, msg = "Expected #{obj.inspect} to be an instance of #{cls}"
+    #    assert cls === obj, msg
+    #  end
+    #
+    #  def assert_kind_of cls, obj, msg = "Expected #{obj.inspect} to be a kind of #{cls}"
+    #    assert obj.kind_of?(cls), msg
+    #  end
+    #
+    #  def assert_match exp, act, msg = "Expected #{act.inspect} to match #{exp.inspect}"
+    #    assert act =~ exp, msg
+    #  end
+    #
+    #  def assert_nil obj, msg = "Expected #{obj.inspect} to be nil"
+    #    assert obj.nil?, msg
+    #  end
+    #
+    #  def assert_no_match exp, act, msg = "Expected #{act.inspect} to not match #{exp.inspect}"
+    #    assert act !~ exp, msg
+    #  end
+    #
+    #  def assert_not_equal exp, act, msg = "Expected #{act.inspect} to not be equal to #{exp.inspect}"
+    #    assert exp != act, msg
+    #  end
+    #
+    #  def assert_not_nil obj, msg = "Expected #{obj.inspect} to not be nil"
+    #    assert ! obj.nil?, msg
+    #  end
+    #
+    #  def assert_not_same exp, act, msg = "Expected #{act.inspect} to not be the same as #{exp.inspect}"
+    #    assert ! exp.equal?(act), msg
+    #  end
+    #
+    #  def assert_nothing_raised
+    #    _increment_assertions
+    #    yield
+    #  rescue => e
+    #    raise StandardError, exception_details(e, "Exception raised:")
+    #  end
+    #
+    #  alias :assert_nothing_thrown :assert_nothing_raised
+    #
+    #  def assert_operator o1, op, o2, msg = "<#{o1.inspect}> expected to be\n#{op.inspect}\n<#{o2.inspect}>."
+    #    assert o1.__send__(op, o2), msg
+    #  end
+    #
+    #  def exception_details e, msg
+    #    "#{msg}\nClass: <#{e.class}>\nMessage: <#{e.message.inspect}>\n---Backtrace---\n#{filter_backtrace(e.backtrace).join("\n")}\n---------------"
+    #  end
+    #
+    #  def assert_raises *exp
+    #    msg = "" #exp.last.kind_of(String) ? exp.pop : nil
+    #    exp = exp.first if exp.size == 1
+    #    begin
+    #      yield
+    #      raise StandardError, "<#{exp.inspect}> exception expected but none was thrown."
+    #    rescue Exception => e
+    #      assert((Array === exp ? exp.include?(e) : exp === e),
+    #        exception_details(e,
+    #          "<#{exp.inspect}> exception expected but was"))
+    #
+    #      return e
+    #    end
+    #  end
+    #  alias :assert_raise :assert_raises
+    #
+    #  def assert_respond_to obj, meth, msg = "Expected #{obj.inspect} of type #{obj.class} to respond_to? #{meth.inspect}"
+    #    assert obj.respond_to?(meth), msg
+    #  end
+    #
+    #  def assert_same exp, act, msg = "Expected #{act.inspect} to be the same as #{exp.inspect}."
+    #    assert exp.equal?(act), msg
+    #  end
+    #
+    #  def assert_send send, msg = nil
+    #    recv, meth, *args = send
+    #    assert(recv.__send__(meth, *args),
+    #      msg || "<#{recv.inspect}> expected to respond to\n<#{meth.inspect}> with a true value.")
+    #  end
+    #
+    #  def assert_throws sym, msg = "<#{sym.inspect}> should have been thrown."
+    #    caught = true
+    #    catch(sym) do
+    #      yield rescue nil
+    #      caught = false
+    #    end
+    #    assert caught, msg
+    #  end
+    #
+    #  def flunk msg = "Flunked"
+    #    assert false, msg
+    #  end
+  end # class TestCase
+  class TestRunner
+    def self.puts(m)
+      message = m.to_s
+      `document.write(#<message>);`
+    end
+    def self.run(klass)
+      @failures, @errors, @assertions = 0,0,0
+      klass.instance_methods.each do |meth|
+        if (meth =~ /^test/)
+          inst = klass.new
+          begin
+            inst.setup
+            inst.send meth
+            puts "."
+          rescue Exception => e
+            puke(klass, meth, e)
+          ensure
+            begin
+              inst.teardown
+            rescue Exception => e
+              puke(klass, meth, e)
+            end
+          end
+          @assertions += inst._assertions
+        end
+      end
+      puts ("<br/>")
+      puts ("Assertions: #{@assertions} Failures: #{@failures}")
+    end
+    def self.puke(klass, meth, e)
+      puts e
+      @failures += 1
+    end
+  end
+end

data/src/rubyjs/model.rb ADDED

@@ -0,0 +1,293 @@
+#
+# Extract the class/module hierarchy and the methods.
+#
+# Copyright (c) 2007 by Michael Neumann (mneumann@ntecs.de).
+# All rights reserved.
+#
+require 'parse_tree'
+require 'sexp_processor'
+require 'enumerator'
+require 'rubyjs/encoder'
+require 'set'
+class MethodExtractor < SexpProcessor
+  attr_accessor :instance_methods, :methods
+  def initialize
+    super()
+    self.strict = false
+    self.auto_shift_type = false
+    self.require_empty = false
+    @instance_methods = {}
+    @methods = {}
+  end
+  def process_defs(exp)
+    defs, _self, name, code, *r = *exp
+    raise unless r.empty?
+    raise unless _self == s(:self)
+    @methods[name.to_s] = s(:defn, name, code)
+    return s()
+  end
+  def process_defn(exp)
+    defn, name, code, *r = *exp
+    raise unless r.empty?
+    @instance_methods[name.to_s] = exp
+    return s()
+  end
+end
+class Model < Encoder
+  SCOPE_R = /^RubyJS::Environment::(.*)$/
+  attr_accessor :models
+  attr_accessor :current_model
+  attr_reader :method_calls
+  def initialize
+    super()
+    #
+    # record all (potential) names of all method calls
+    #
+    @method_calls = Set.new
+    @models = {}
+    # all modules and classes (a Class is_a Module)
+    ObjectSpace.each_object {|o|
+      @models[o] = model_for(o) if o.is_a?(::Module) && o.name =~ SCOPE_R
+    }
+  end
+  def add_method_call(name)
+    @method_calls.add(name)
+  end
+  def iterate_all(seen, &block)
+    @models.each_value do |v|
+      iterate_rec(v, seen, &block)
+    end
+  end
+  def iterate_rec(model, seen, &block)
+    return if seen.include?(model[:for])
+    iterate_rec(@models[model[:superclass]], seen, &block) if model[:superclass]
+    model[:modules].each do |m|
+      iterate_rec(@models[m], seen, &block)
+    end
+    with_current_model(model) do
+      block.call(model)
+    end
+    seen.add(model[:for])
+  end
+  alias old_encode_constant encode_constant
+  def encode_constant(name)
+    if @current_model
+      lookup_constant(name)
+    else
+      old_encode_constant(name)
+    end
+  end
+  #
+  # Compile time constant lookup.
+  #
+  # Lookup rules (like Ruby 1.9+):
+  #
+  #   1. Current class
+  #   2. Super classes except object
+  #   3. lexically enclosing modules/classes
+  #   4. Object
+  #
+  def lookup_constant(name)
+    model = @current_model
+    prefix, *path = name.split("::")
+    start_lookup_at = nil
+    done = false
+    if prefix.empty?
+      # e.g. "::A"
+      start_lookup_at = RubyJS::Environment
+      done = true
+    else
+      # 1. Current class
+      if model[:for].constants.include?(prefix)
+        start_lookup_at = model[:for].const_get(prefix)
+        done = true
+      end
+      # 2. Super classes except object
+      unless done
+        m = model
+        loop do
+          if m[:superclass] and m[:superclass] != RubyJS::Environment::Object
+            if m[:superclass].constants.include?(prefix)
+              start_lookup_at = m[:superclass].const_get(prefix)
+              done = true
+              break
+            else
+              m = @models[m[:superclass]]
+            end
+          else
+            break
+          end
+        end
+      end
+      # 3. lexically enclosing modules/classes
+      # FIXME
+      unless done
+        arr = model[:name].split("::")
+        loop do
+          arr.pop
+          begin
+            start_lookup_at = eval((["RubyJS", "Environment"] + arr + [prefix]).join("::"))
+            done = true
+            break
+          rescue NameError
+          end
+          break if arr.empty?
+        end
+      end
+      # 4. Object
+      unless done
+        begin
+          start_lookup_at = RubyJS::Environment::Object.const_get(prefix)
+          done = true
+        rescue NameError
+        end
+      end
+    end
+    unless done
+      raise "failed to lookup constant prefix #{prefix}"
+    end
+    #
+    # follow the whole path, e.g. A::B::C
+    #
+    value = start_lookup_at
+    path.each do |piece|
+      value = value.const_get(piece)
+    end
+    if value.is_a?(::Class) or value.is_a?(::Module)
+      # A class or module
+      if model = @models[value]
+        return old_encode_constant(model[:name])
+      else
+        raise("unrecognized class/module referenced by constant")
+      end
+    else
+      # A value
+      if value.is_a?(Fixnum)
+        # If it is the receiver of a method call, we have to surround it
+        # with parens, e.g. (1).
+        # As we can't easily decide whether it's a receiver of a method
+        # call, we simply surround every constant Fixnum with parens.
+        return "(" + value.inspect + ")"
+      elsif value.is_a?(String)
+        # FIXME: Generate a reference instead?
+        return value.inspect
+      else
+        raise
+      end
+    end
+  end
+  def namify(klass)
+    name = klass.name
+    if name =~ SCOPE_R
+      name = $1
+    else
+      raise "must be scoped inside RubyJS module"
+    end
+    return name
+  end
+  def with_current_model(model)
+    old_current_model = @current_model
+    @current_model = model
+    begin
+      yield
+    ensure
+      @current_model = old_current_model
+    end
+  end
+  def model_for(klass)
+    name = namify(klass)
+    me = MethodExtractor.new
+    me.process(*ParseTree.new.parse_tree(klass))
+    if klass.is_a?(::Class)
+      a = klass.ancestors
+      a = a[0...(a.index(::Object))]
+      s = klass.superclass
+      s = nil if s == ::Object
+      # remove klass from the ancestor chain
+      a = a[1..-1] if a[0] == klass
+      # a now contains the included modules
+      a = a[0...(a.index(s))] if s
+      if klass == RubyJS::Environment::Object
+        raise unless s.nil?
+        s = nil
+      else
+        if s.nil?
+          s = RubyJS::Environment::Object
+        end
+      end
+      return {
+        :for => klass,
+        :modules => a,
+        :superclass => s,
+        :is_a => :class,
+        :name => name,
+        :instance_methods => me.instance_methods,
+        :methods => me.methods
+      }
+    elsif klass.is_a?(::Module)
+      a = klass.ancestors
+      # remove klass from the ancestor chain
+      a = a[1..-1] if a[0] == klass
+      return {
+        :for => klass,
+        :modules => a,
+        :is_a => :module,
+        :name => name,
+        :instance_methods => me.instance_methods,
+        :methods => me.methods
+      }
+    else
+      raise
+    end
+  end
+end