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

superchris-rubyjs 0.8.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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