jbarnette-johnson 1.0.0.200806240111

data/lib/johnson.rb

@@ -0,0 +1,46 @@
+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"
+
+$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
+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,56 @@
+require "optparse"
+
+module Johnson #:nodoc:
+  module CLI #:nodoc:
+    class Options #:nodoc:
+      class << self
+        alias_method :parse!, :new
+      end
+      
+      attr_reader :expressions, :load_paths, :files_to_preload, :file_to_evaluate, :arguments
+    
+      def initialize(*args)
+        argv = args.flatten
+        @expressions = []
+        @load_paths = []
+        @files_to_preload = []
+
+        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("-i [FILE]", "Evaluate [FILE] before interaction") do |file|
+            @files_to_preload << file
+          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)
+
+        @file_to_evaluate = argv.shift
+        @arguments = 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,64 @@
+module Johnson
+  module Nodes
+    BINARY_NODES = %w{
+      And
+      DoWhile
+      Case
+      Default
+      While
+      With
+      In
+      Switch
+      InstanceOf
+      AssignExpr
+      BracketAccess
+      DotAccessor
+      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,27 @@
+module Johnson
+  module Nodes
+    LIST_NODES = %w{
+      SourceElements
+      VarStatement
+      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

data/lib/johnson/nodes/ternary_node.rb

@@ -0,0 +1,20 @@
+module Johnson
+  module Nodes
+    TERNARY_NODES = %w{
+      Ternary
+      If
+      Try
+      Catch
+    }
+    class TernaryNode < Node
+      alias :b_else :value
+      attr_accessor :cond, :b_then
+      def initialize(line, column, cond, b_then, b_else)
+        super(line, column, b_else)
+        @cond   = cond
+        @b_then = b_then
+      end
+    end
+    TERNARY_NODES.each { |bn| const_set(bn.to_sym, Class.new(TernaryNode)) }
+  end
+end

data/lib/johnson/parser.rb

@@ -0,0 +1,21 @@
+require 'stringio'
+require 'johnson/parser/syntax_error'
+
+module Johnson
+  module Parser
+    class << self
+      def parse(js, filename = nil, linenum = nil)
+        tree = if js.is_a?(String)
+          parse_io(StringIO.new(js), filename, linenum)
+        else
+          parse_io(js, filename, linenum)
+        end
+        tree.to_mutable_tree
+      end
+
+      def parse_io(js, filename = nil, linenum = nil)
+        Johnson::SpiderMonkey::ImmutableNode.parse_io(js, filename, linenum)
+      end
+    end
+  end
+end

data/lib/johnson/parser/syntax_error.rb

@@ -0,0 +1,13 @@
+module Johnson
+  module Parser
+    class SyntaxError < RuntimeError
+      attr_accessor :message, :file_name, :line_number
+      def initialize(message, file_name, line_number)
+        super("#{message} in (#{file_name || "nil"}): #{line_number}")
+        @message      = message
+        @file_name    = file_name
+        @line_number  = line_number
+      end
+    end
+  end
+end

data/lib/johnson/runtime.rb

@@ -0,0 +1,55 @@
+module Johnson
+  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)
+      global.Johnson.runtime = self
+    end
+    
+    def [](key)
+      delegate[key.to_s]
+    end
+    
+    def []=(key, value)
+      delegate[key.to_s] = value
+    end
+    
+    def evaluate(expression, filename=nil, linenum=nil)
+      return nil if expression.nil?
+      delegate.evaluate(expression, filename, linenum)
+    end
+    
+    def global
+      delegate.global
+    end
+    
+    def load(file)
+      delegate.evaluate(IO.read(file), file, 1)
+    end
+
+    ###
+    # Compile +script+ with +filename+ and +linenum+
+    def compile(script, filename=nil, linenum=nil)
+      delegate.compile(script, filename, linenum)
+    end
+
+    ###
+    # Yield to +block+ in +filename+ at +linenum+
+    def break(filename, linenum, &block)
+      delegate.break(filename, linenum, &block)
+    end
+
+    def evaluate_compiled_script(script)
+      delegate.evaluate_compiled_script(script)
+    end
+
+    private
+    # Called by SpiderMonkey's garbage collector to determine whether or
+    # not it should GC
+    def should_sm_gc?
+      false
+    end
+  end
+end