johnson 1.1.0

data/js/johnson/cli.js

@@ -0,0 +1,30 @@
+Ruby.require("uri");
+Ruby.require("open-uri");
+
+function load() {
+  for (var i = 0; i < arguments.length; ++i)
+    Johnson.require(arguments[i]);
+}
+
+function print() {
+  for (var i = 0; i < arguments.length; ++i)
+    Ruby.puts(arguments[i]);
+}
+
+// NOTE: the Rhino version takes an optional encoding
+function readFile(path) {
+  return Ruby.IO.read(path);
+}
+
+// NOTE: the Rhino version takes an optional encoding
+function readUrl(url) {
+  return Ruby.URI.parse(url).read();
+}
+
+function quit() {
+  Ruby.exit();
+}
+
+function version() {
+  return Ruby.Johnson.VERSION;
+}

data/js/johnson/prelude.js

@@ -0,0 +1,80 @@
+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);
+
+Johnson.Generator = function(enumerableProxy) {
+  this.items = enumerableProxy.toArray();
+  this.index = 0;
+};
+
+Johnson.Generator.prototype.hasNext = function() {
+  var len = this.items.length;
+  if (typeof len != 'number') len = this.items.length();
+  return this.index < len;
+}
+
+Johnson.Generator.prototype.next = function() {
+  if (this.hasNext()) {
+    return this.items[this.index++];
+  }
+  throw StopIteration;
+}
+
+Johnson.Generator.create = function() {
+  return new Johnson.Generator(this);
+}
+
+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.rb

@@ -0,0 +1,55 @@
+require "generator"
+require "johnson/version"
+
+# the command-line option parser and support libs
+require "johnson/cli"
+
+# the native SpiderMonkey extension
+require "johnson/spidermonkey"
+
+# visitable module and visitors
+require "johnson/visitable"
+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"))
+
+module Johnson
+  PRELUDE = IO.read(File.dirname(__FILE__) + "/../js/johnson/prelude.js")
+  
+  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.
+  def self.load(*files)
+    rt = Johnson::Runtime.new
+    rt.load(*files)
+    rt
+  end
+end

data/lib/johnson/cli.rb

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

data/lib/johnson/cli/options.rb

@@ -0,0 +1,67 @@
+require "optparse"
+
+module Johnson #:nodoc:
+  module CLI #:nodoc:
+    class Options #:nodoc:
+      class << self
+        alias_method :parse!, :new
+      end
+      
+      attr_reader :arguments
+      attr_reader :expressions
+      attr_reader :files_to_preload
+      attr_reader :files_to_evaluate
+      attr_reader :load_paths
+      attr_reader :paths_to_require
+    
+      def initialize(*args)
+        @arguments = []
+        @expressions = []
+        @load_paths = []
+        @files_to_preload = []
+        @paths_to_require = []
+
+        argv = args.flatten
+        
+        if index = argv.index("--")
+          @arguments = argv[(index+1)..-1]
+          argv = argv[0..index]
+        end
+
+        parser = OptionParser.new do |parser|
+          parser.banner = "Usage: johnson [options] [file.js...] [-- jsargs...]"
+          parser.version = Johnson::VERSION
+
+          parser.on("-e [EXPRESSION]", "Evaluate [EXPRESSION] and exit") do |expression|
+            @expressions << expression
+          end
+      
+          parser.on("-I [DIRECTORY]", "Specify $LOAD_PATH directories") do |dir|
+            @load_paths << dir
+          end
+
+          parser.on("-i [FILE]", "Evaluate [FILE] before interaction") do |file|
+            @files_to_preload << file
+          end
+          
+          parser.on("-r [PATH]", "Require [PATH] before executing") do |path|
+            @paths_to_require << path
+          end
+      
+          parser.on("-h", "-?", "--help", "Show this message") do
+            puts parser
+            exit
+          end
+      
+          parser.on("-v", "--version", "Show Johnson's version (#{Johnson::VERSION})") do
+            puts Johnson::VERSION
+            exit
+          end  
+        end
+        
+        parser.parse!(argv)
+        @files_to_evaluate = argv.dup
+      end 
+    end
+  end
+end

data/lib/johnson/error.rb

@@ -0,0 +1,4 @@
+module Johnson
+  class Error < StandardError
+  end
+end

data/lib/johnson/nodes.rb

@@ -0,0 +1,7 @@
+require 'johnson/nodes/node'
+require 'johnson/nodes/function'
+require 'johnson/nodes/list'
+require 'johnson/nodes/for'
+require 'johnson/nodes/for_in'
+require 'johnson/nodes/ternary_node'
+require 'johnson/nodes/binary_node'

data/lib/johnson/nodes/binary_node.rb

@@ -0,0 +1,65 @@
+module Johnson
+  module Nodes
+    BINARY_NODES = %w{
+      And
+      DoWhile
+      Case
+      Default
+      While
+      With
+      In
+      Switch
+      InstanceOf
+      AssignExpr
+      BracketAccess
+      DotAccessor
+      LexicalScope
+      Equal
+      GetterProperty
+      Label
+      GreaterThan
+      LessThan
+      GreaterThanOrEqual
+      LessThanOrEqual
+      NotEqual
+      OpAdd
+      OpAddEqual
+      OpBitAnd
+      OpBitAndEqual
+      OpBitOr
+      OpBitOrEqual
+      OpBitXor
+      OpBitXorEqual
+      OpDivide
+      OpDivideEqual
+      OpEqual
+      OpLShift
+      OpLShiftEqual
+      OpMod
+      OpModEqual
+      OpMultiply
+      OpMultiplyEqual
+      OpRShift
+      OpRShiftEqual
+      OpSubtract
+      OpSubtractEqual
+      OpURShift
+      OpURShiftEqual
+      Or
+      Property
+      SetterProperty
+      StrictEqual
+      StrictNotEqual
+    }
+
+    class BinaryNode < Node
+      alias :right :value
+      attr_accessor :left
+      def initialize(line, column, left, right)
+        super(line, column, right)
+        @left = left
+      end
+    end
+    BINARY_NODES.each { |bn| const_set(bn.to_sym, Class.new(BinaryNode)) }
+  end
+end

data/lib/johnson/nodes/for.rb

@@ -0,0 +1,14 @@
+module Johnson
+  module Nodes
+    class For < Node
+      alias :body :value
+      attr_accessor :init, :cond, :update
+      def initialize(line, column, init, cond, update, body)
+        super(line, column, body)
+        @init   = init
+        @cond   = cond
+        @update = update
+      end
+    end
+  end
+end

data/lib/johnson/nodes/for_in.rb

@@ -0,0 +1,12 @@
+module Johnson
+  module Nodes
+    class ForIn < Node
+      alias :body :value
+      attr_accessor :in_cond
+      def initialize(line, column, in_cond, body)
+        super(line, column, body)
+        @in_cond = in_cond
+      end
+    end
+  end
+end

data/lib/johnson/nodes/function.rb

@@ -0,0 +1,13 @@
+module Johnson
+  module Nodes
+    class Function < Node
+      alias :body :value
+      attr_accessor :name, :arguments
+      def initialize(line, column, name, arguments, body)
+        super(line, column, body)
+        @name       = name
+        @arguments  = arguments
+      end
+    end
+  end
+end

data/lib/johnson/nodes/list.rb

@@ -0,0 +1,28 @@
+module Johnson
+  module Nodes
+    LIST_NODES = %w{
+      SourceElements
+      VarStatement
+      LetStatement
+      Comma
+      ObjectLiteral
+      ArrayLiteral
+      New
+      FunctionCall
+      Import
+      Export
+    }
+    # This is an abstract node used for nodes of list type
+    # see SourceElements
+    class List < Node
+      def initialize(line, column, value = [])
+        super
+      end
+
+      def <<(obj)
+        self.value << obj
+      end
+    end
+    LIST_NODES.each { |ln| const_set(ln.to_sym, Class.new(List)) }
+  end
+end

data/lib/johnson/nodes/node.rb

@@ -0,0 +1,68 @@
+module Johnson
+  module Nodes
+    SINGLE_NODES = %w{
+      BitwiseNot
+      Break
+      Continue
+      Delete
+      False
+      Name
+      Not
+      Null
+      Number
+      Parenthesis
+      PostfixIncrement
+      PrefixIncrement
+      PostfixDecrement
+      PrefixDecrement
+      Regexp
+      Return
+      String
+      This
+      Throw
+      True
+      Typeof
+      UnaryNegative
+      UnaryPositive
+      Void
+    }
+    class Node
+      include Johnson::Visitable
+      include Johnson::Visitors
+
+      attr_accessor :value
+      attr_reader :line, :column
+      def initialize(line, column, value)
+        @line = line
+        @column = column
+        @value = value
+      end
+
+      def to_s
+        to_sexp.inspect
+      end
+
+      alias_method :inspect, :to_s
+
+      def to_sexp
+        SexpVisitor.new.accept(self)
+      end
+
+      def to_ecma
+        EcmaVisitor.new.accept(self)
+      end
+
+      alias_method :to_js, :to_ecma
+
+      def to_dot
+        DotVisitor.new { |d| d.accept(self) }
+      end
+
+      def each(&block)
+        EnumeratingVisitor.new(block).accept(self)
+        self
+      end
+    end
+    SINGLE_NODES.each { |se| const_set(se.to_sym, Class.new(Node)) }
+  end
+end