rubyjs 0.7.0

data/src/rubyjs/lib/json.rb

@@ -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/model.rb

@@ -0,0 +1,287 @@
+#
+# 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_defn(exp)
+    defn, name, code = *exp  
+    name = name.to_s
+    if name =~ /^self\.(.*)$/
+      @methods[$1] = exp
+    else
+      @instance_methods[name] = exp
+    end
+    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

data/src/rubyjs/name_generator.rb

@@ -0,0 +1,71 @@
+#
+# Generate unique names from a (custom) alphabet.
+#
+# Copyright (c) 2007 by Michael Neumann (mneumann@ntecs.de).
+# All rights reserved.
+#
+
+class NameGenerator
+
+  DEFAULT_ALPHABET = ('a' .. 'z').to_a + ('A' .. 'Z').to_a + ('0' .. '9').to_a + ['_', '$']
+  RESERVED_WORDS = %w(this self new break continue if then else while true false null undefined function document window) 
+
+  def initialize(alphabet=DEFAULT_ALPHABET, reserved_words=RESERVED_WORDS)
+    @alphabet = alphabet
+    @reserved_words = reserved_words
+    @digits = [0]
+    @cache = {}
+  end
+  
+  # 
+  # We generate names using a g-adic development (where g=alphabet.size)
+  #
+  # The least significant digit is the first. If you think of it as a 
+  # bit-string, then bit 0 would be @digits[0].
+  #
+  # In each call to next we try to increase the least significant digit.
+  # If it overflows, then we reset it to zero and increase the next digit.
+  # This continues up to the most significant digit. If this overflows,
+  # we introduce a new most significant digit and set this to "zero".
+  #
+
+  def fresh
+    loop do
+      value = @digits.reverse.map {|d| @alphabet[d] }.join("")
+      sz = @alphabet.size
+
+      i = 0
+      loop do
+        # increase or initialize with 0
+        @digits[i] = @digits[i] ? @digits[i]+1 : 0
+
+        if @digits[i] >= sz
+          @digits[i] = 0
+          i += 1
+        else
+          break
+        end
+      end
+
+      return value unless @reserved_words.include?(value)
+    end
+  end
+
+  #
+  # Generate a name for +name+. Return the same name for the same
+  # +name+.
+  #
+
+  def get(name)
+    raise unless name.is_a?(String)
+    @cache[name] ||= self.fresh
+  end
+
+  def reverse_lookup(encoded_name)
+    @cache.index(encoded_name)
+  end
+
+  def cache
+    @cache
+  end
+end