johnson 1.1.2 → 1.2.0

data/ext/spidermonkey/runtime.h

@@ -3,6 +3,8 @@
 
 #include "spidermonkey.h"
 
+//#define LEAK_ROOT_NAMES
+
 #define RAISE_JS_ERROR(rb_runtime, ex) \
   do {\
     JohnsonRuntime * _rt = NULL;\

data/ext/spidermonkey/spidermonkey.c

@@ -6,7 +6,9 @@
 
 void Init_spidermonkey()
 {
-  VALUE johnson = rb_define_module("Johnson"); // FIXME: this belongs outside the extension
+  JS_SetCStringsAreUTF8();
+
+  VALUE johnson = rb_const_get(rb_mKernel, rb_intern("Johnson"));
   VALUE spidermonkey = rb_define_module_under(johnson, "SpiderMonkey");
   
   init_Johnson_SpiderMonkey_Context(spidermonkey);

data/lib/johnson.rb

@@ -1,11 +1,10 @@
 require "generator"
-require "johnson/version"
 
-# the command-line option parser and support libs
-require "johnson/cli"
-
-# the native SpiderMonkey extension
-require "johnson/spidermonkey"
+# the 'public' interface
+require "johnson/error"
+require "johnson/runtime"
+require "johnson/ruby_land_proxy"
+require "johnson/parser"
 
 # visitable module and visitors
 require "johnson/visitable"
@@ -14,39 +13,32 @@ require "johnson/visitors"
 # parse tree nodes
 require "johnson/nodes"
 
-# the SpiderMonkey bits written in Ruby
-require "johnson/spidermonkey/runtime"
-require "johnson/spidermonkey/context"
-require "johnson/spidermonkey/js_land_proxy"
-require "johnson/spidermonkey/ruby_land_proxy"
-require "johnson/spidermonkey/mutable_tree_visitor"
-require "johnson/spidermonkey/debugger"
-require "johnson/spidermonkey/immutable_node"
-
-# the 'public' interface
-require "johnson/error"
-require "johnson/runtime"
-require "johnson/parser"
-
-# make sure all the Johnson JavaScript libs are in the load path
-$LOAD_PATH.push(File.expand_path("#{File.dirname(__FILE__)}/../js"))
+# SpiderMonkey, the default JS engine
+require "johnson/spidermonkey"
 
 module Johnson
-  PRELUDE = IO.read(File.dirname(__FILE__) + "/../js/johnson/prelude.js")
-  
+  VERSION = "1.2.0"
+
+  ###
+  # Evaluate the given JavaScript +expression+ in a new runtime, after
+  # setting the given +vars+ into the global object.
+  #
+  # Returns the result of evaluating the given expression.
   def self.evaluate(expression, vars={})
     runtime = Johnson::Runtime.new
     vars.each { |key, value| runtime[key] = value }
-    
+
     runtime.evaluate(expression)
   end
-  
+
   def self.parse(js, *args)
     Johnson::Parser.parse(js, *args)
   end
 
   ###
-  # Create a new runtime and load all +files+.  Returns a new Johnson::Runtime.
+  # Create a new runtime and load all +files+.
+  #
+  # Returns the new Johnson::Runtime.
   def self.load(*files)
     rt = Johnson::Runtime.new
     rt.load(*files)

data/lib/johnson/cli.rb

@@ -1,7 +1,8 @@
+require "johnson"
 require "johnson/cli/options"
 
 module Johnson #:nodoc:
   module CLI #:nodoc:
-    JS = IO.read(File.dirname(__FILE__) + "/../../js/johnson/cli.js")
+    JS = IO.read File.dirname(__FILE__) + "/js/cli.js"
   end
 end

data/lib/johnson/js/core.js

@@ -0,0 +1,34 @@
+
+// Ruby ProxyHelper => JS original
+Johnson.addConversion(function(v) {
+  return v.javascript_proxy;
+}, (function(Helper_send) {
+  return function(v) {
+    return Helper_send('===', v);
+  };
+})(Ruby.Johnson.RubyLandProxy.ProxyHelper.method('send')));
+
+
+// Ruby Time => JS Date
+Johnson.addWrapper(function(v) {
+  var d = new Date(v.to_f() * 1000);
+  d.wrappedRuby = v;
+  return d;
+}, (function(Helper_send, RubyTime_send) {
+  return function(v) {
+    return !Helper_send('===', v) && RubyTime_send('===', v);
+  };
+})(Ruby.Johnson.RubyLandProxy.ProxyHelper.method('send'), Ruby.Time.method('send')));
+
+
+// Ruby Date/DateTime => JS Date
+Johnson.addWrapper(function(v) {
+  var d = new Date(parseFloat(v.strftime('%Q')));
+  d.wrappedRuby = v;
+  return d;
+}, (function(Helper_send, RubyDate_send) {
+  return function(v) {
+    return !Helper_send('===', v) && RubyDate_send('===', v);
+  };
+})(Ruby.Johnson.RubyLandProxy.ProxyHelper.method('send'), Ruby.Date.method('send')));
+

data/lib/johnson/js/prelude.js

@@ -0,0 +1,149 @@
+var Johnson = {};
+
+Johnson.Symbol = function(string) {
+  this.string = string;
+};
+
+Johnson.Symbol.prototype = {
+  toString: function() {
+    return this.string;
+  },
+
+  inspect: function() {
+    return ":" + this.toString();
+  }
+};
+
+Johnson.symbolCache = {};
+
+Johnson.symbolize = function(string) {
+  if (!Johnson.symbolCache[string])
+    Johnson.symbolCache[string] = new Johnson.Symbol(string);
+    
+  return Johnson.symbolCache[string];
+};
+
+Object.defineProperty(String.prototype, "toSymbol", function() {
+  return Johnson.symbolize(this.toString());
+}, Object.READ_ONLY | Object.NON_DELETABLE);
+
+(function(origApply) {
+  Object.defineProperty(Function.prototype, "apply", function(thisObj, arrayLike) {
+    var realArray = arrayLike;
+    if (arrayLike != null &&
+        !(arrayLike instanceof Array) &&
+        typeof arrayLike == 'object' &&
+        arrayLike.length != null) {
+      realArray = [];
+      for (var i = arrayLike.length - 1; i >= 0; i--) {
+        realArray[i] = arrayLike[i];
+      }
+    }
+    return origApply.call(this, thisObj, realArray);
+  }, Object.READ_ONLY | Object.NON_DELETABLE);
+})(Function.prototype.apply);
+
+(function() {
+  var wrappers = [];
+  var conversions = [];
+  Johnson.addConversion = function(conversion, test) {
+    conversions.push([conversion, test]);
+  };
+  Johnson.applyConversions = function(proxy) {
+    var converted = false;
+    conversions.forEach(function(pair) {
+      if (converted) return;
+
+      var [conversion, test] = pair;
+
+      if (test(proxy)) {
+        proxy = conversion(proxy);
+        converted = true;
+      }
+    });
+    return proxy;
+  };
+  Johnson.addWrapper = function(wrapper, test) {
+    wrappers.push([wrapper, test]);
+  };
+  Johnson.applyWrappers = function(proxy) {
+    wrappers.forEach(function(pair) {
+      var [wrapper, test] = pair;
+
+      if (test && !test(proxy)) return;
+      if (wrapper.test && !wrapper.test(proxy)) return;
+
+      if (typeof wrapper == 'function')
+        proxy = wrapper(proxy);
+      else
+        for (var [m, v] in wrapper)
+          proxy[m] = v;
+    });
+    return proxy;
+  };
+})();
+
+Johnson.Generator = function(enumerableProxy, namesOnly) {
+  if (enumerableProxy.js_properties) {
+    this.items = enumerableProxy.js_properties();
+  } else {
+    this.items = (enumerableProxy.keys ? enumerableProxy.keys() : []).concat(enumerableProxy.methods());
+  }
+  this.index = 0;
+  if (!namesOnly)
+    this.obj = enumerableProxy;
+};
+
+Johnson.Generator.prototype.__iterator__ = function() {
+  return this;
+};
+
+Johnson.Generator.prototype.hasNext = function() {
+  return this.index < this.items.length;
+}
+
+Johnson.Generator.prototype.next = function() {
+  if (this.hasNext()) {
+    var name = this.items[this.index++];
+    if (this.obj) {
+      return [name, this.obj[name]];
+    } else {
+      return name;
+    }
+  }
+  throw StopIteration;
+}
+
+Johnson.Generator.create = function(namesOnly) {
+  return new Johnson.Generator(this, namesOnly);
+}
+
+Johnson.required = {};
+
+Johnson.require = function(file) {
+  file = Ruby.File.join(Ruby.File.dirname(file),
+    Ruby.File.basename(file, ".js") + ".js");
+  
+  if(Johnson.required[file]) return false;
+  
+  for(var directory in Ruby["$LOAD_PATH"]) {
+    var path = Ruby.File.join(directory, file);
+    
+    if(Ruby.File.send("file?", path)) {
+      Johnson.required[file] = true;
+      Johnson.runtime.load(path);
+      
+      return true;
+    }
+  }
+  
+  throw Ruby.LoadError;
+}
+
+this.__defineGetter__("__FILE__", function() { 
+  try { throw new Error; } catch(e) {
+    return e.stack.split("\n")[2].split("@")[1].split(":").slice(0,-1).join(":");
+  }
+})
+
+null; // no need to marshal a result

data/lib/johnson/ruby_land_proxy.rb

@@ -0,0 +1,113 @@
+module Johnson #:nodoc:
+  class RubyLandProxy
+    class << self
+      def apply_wrappers(proxy)
+        wrappers.each do |(wrapper, test)|
+          next if test && !test.call(proxy)
+          next if wrapper.respond_to?(:test?) && !wrapper.test?(proxy)
+
+          if wrapper.respond_to?(:call)
+            proxy = wrapper.call(proxy)
+            break unless Johnson::RubyLandProxy === proxy
+          else
+            proxy.send :extend, wrapper
+          end
+        end
+        proxy
+      end
+      def add_wrapper(wrapper, &test)
+        wrappers.push [wrapper, test]
+      end
+      def insert_wrapper(wrapper, &test)
+        wrappers.unshift [wrapper, test]
+      end
+      def wrappers
+        @wrappers ||= []
+      end
+
+      def apply_conversions(proxy)
+        conversions.each do |(conversion, test)|
+          if test.call(proxy)
+            converted = conversion.call(proxy)
+            return converted unless converted.eql? proxy
+          end
+        end
+        proxy
+      end
+      def add_conversion(conversion, &test)
+        conversions << [conversion, test]
+      end
+      def conversions
+        @conversions ||= []
+      end
+    end
+
+    module Callable
+      def self.test?(proxy)
+        proxy.respond_to?(:call_using)
+      end
+
+      def to_proc
+        @proc ||= Proc.new { |*args| call(*args) }
+      end
+
+      def call(*args)
+        call_using(runtime.global, *args)
+      end
+    end
+
+    module ProxyHelper
+      def self.wrap(proxy, result)
+        result.extend self
+        result.javascript_proxy = proxy
+        result
+      end
+
+      attr_accessor :javascript_proxy
+    end
+
+    add_wrapper Callable
+
+    # JS wrapper => Ruby original
+    add_conversion lambda {|o| o.wrappedRuby } do |o| o.respond_to? :wrappedRuby end
+
+    # JS Date => Ruby DateTime
+    add_conversion lambda {|o| ProxyHelper.wrap(o, DateTime.parse(o.toUTCString)) } do |o| o.respond_to? :setUTCMilliseconds end
+
+    include Enumerable
+
+    # FIXME: need to revisit array vs non-array proxy, to_a/to_ary semantics, etc.
+    def size; length; end
+    def to_ary; to_a; end
+
+    def initialize
+      raise Johnson::Error, "#{self.class.name} is an internal support class."
+    end
+    private :initialize
+
+    def inspect
+      toString
+    end
+
+    def method_missing(sym, *args, &block)
+      args << block if block_given?
+
+      name = sym.to_s
+      assignment = "=" == name[-1, 1]
+
+      # default behavior if the slot's not there
+      return super unless assignment || respond_to?(sym)
+
+      unless function_property?(name)
+        # for arity 0, treat it as a get
+        return self[name] if args.empty?
+
+        # arity 1 and quacking like an assignment, treat it as a set
+        return self[name[0..-2]] = args[0] if assignment && 1 == args.size
+      end
+
+      # okay, must really be a function
+      call_function_property(name, *args)
+    end
+  end
+end

data/lib/johnson/runtime.rb

@@ -1,36 +1,104 @@
 module Johnson
+  ###
+  # An interface to a JavaScript engine.
   class Runtime
-    attr_reader :delegate
-    
-    def initialize(delegate=Johnson::SpiderMonkey::Runtime)
-      @delegate = delegate.is_a?(Class) ? delegate.new : delegate
-      evaluate(Johnson::PRELUDE, "Johnson::PRELUDE", 1)
+
+    PRELUDE_PATH = File.expand_path File.dirname(__FILE__) +
+      "/js/prelude.js" # :nodoc:
+    CORE_PATH = File.expand_path File.dirname(__FILE__) +
+      "/js/core.js" # :nodoc:
+
+    PRELUDE = IO.read PRELUDE_PATH # :nodoc:
+    CORE = IO.read CORE_PATH # :nodoc:
+
+    ###
+    # Deprecated: Previously, returned the underlying JavaScript engine
+    # instance. Now returns self.
+    def delegate
+      self
+    end
+
+    ###
+    # Create a new Runtime instance, using the default JavaScript
+    # engine.
+    #
+    # Optionally takes a parameter specifying which engine to use, but
+    # this is deprecated; instead, just create an instance of that
+    # engine's runtime directly.
+    #
+    # :call-seq:
+    #   new(runtime_class=nil)
+    #
+    def self.new(*args)
+      return super if self < Johnson::Runtime
+
+      delegate = args.first
+      if delegate.is_a? Class
+        delegate.new
+      elsif delegate
+        delegate
+      else
+        Johnson::SpiderMonkey::Runtime.new
+      end
+    end
+
+    ###
+    # Install the Johnson prelude into this runtime environment.
+    def initialize # :notnew:
+      evaluate PRELUDE, PRELUDE_PATH, 1
       global.Johnson.runtime = self
+      global['Ruby'] = Object
+      evaluate CORE, CORE_PATH, 1
     end
-    
+
+    ###
+    # Access the +key+ property of the JavaScript +global+ object.
     def [](key)
-      delegate[key.to_s]
+      global[key]
     end
-    
+
+    ###
+    # Set the +key+ property of the JavaScript +global+ object to
+    # +value+.
     def []=(key, value)
-      delegate[key.to_s] = value
+      global[key] = value
     end
-    
-    def evaluate(expression, filename=nil, linenum=nil)
-      return nil if expression.nil?
-      delegate.evaluate(expression, filename, linenum)
+
+
+    ###
+    # Execute the JavaScript source in +script+. If supplied, the script
+    # is marked as starting on line +linenum+ of +filename+.
+    #
+    # Equivalent to calling RubyLandScript#execute on the result of
+    # Runtime#compile.
+    def evaluate(script, filename = nil, linenum = nil)
+      return nil if script.nil?
+      compiled_script = compile(script, filename, linenum)
+      evaluate_compiled_script(compiled_script)
     end
-    
+
+
+    ###
+    # The JavaScript unique Global Object.
     def global
-      delegate.global
+      raise NotImplementedError
     end
-    
+
+    ###
+    # Load and execute the named JavaScript +files+.
+    #
+    # Checks for (and skips) a shebang line at the top of any of them.
     def load(*files)
-      files.map { |f| delegate.evaluate(File.read(f).gsub(/\A#!.*$/, ''), f, 1) }.last
+      files.map { |f|
+        evaluate(File.read(f).gsub(/\A#!.*$/, ''), f, 1)
+      }.last
     end
 
     ###
-    # Johnson.require on each file in +files+
+    # Search the Ruby load path for each of the named +files+, and
+    # evaluate them *if they have not yet been loaded*.
+    #
+    # Calls Johnson.require() in JavaScript on each filename in turn.
     def require(*files)
       files.each do |file|
         evaluate("Johnson.require('#{file}');")
@@ -38,26 +106,17 @@ module Johnson
     end
 
     ###
-    # Compile +script+ with +filename+ and +linenum+
+    # Compile the JavaScript source in +script+. If supplied, the script
+    # is marked as starting on line +linenum+ of +filename+.
     def compile(script, filename=nil, linenum=nil)
-      delegate.compile(script, filename, linenum)
+      raise NotImplementedError
     end
 
     ###
-    # Yield to +block+ in +filename+ at +linenum+
-    def break(filename, linenum, &block)
-      delegate.break(filename, linenum, &block)
-    end
-
+    # Evaluates the given JS script, that should have been returned by a
+    # previous call to #compile().
     def evaluate_compiled_script(script)
-      delegate.evaluate_compiled(script)
-    end
-
-    private
-    # Called by SpiderMonkey's garbage collector to determine whether or
-    # not it should GC
-    def should_sm_gc?
-      false
+      raise NotImplementedError
     end
   end
 end