johnson 1.1.0

data/lib/johnson/visitors/enumerating_visitor.rb

@@ -0,0 +1,15 @@
+module Johnson
+  module Visitors
+    class EnumeratingVisitor < Visitor
+      attr_accessor :block
+      def initialize(block)
+        @block = block
+      end
+
+      superclass.instance_methods.each do |method|
+        next unless method.to_s =~ /^visit_/
+        eval("def #{method}(o); block.call(o); super; end")
+      end
+    end
+  end
+end

data/lib/johnson/visitors/sexp_visitor.rb

@@ -0,0 +1,174 @@
+module Johnson
+  module Visitors
+    class SexpVisitor
+      def visit_SourceElements(o)
+        o.value.map { |x| x.accept(self) }
+      end
+
+      {
+        'VarStatement'  => :var,
+        'LetStatement'  => :let,
+        'Comma'         => :comma,
+        'ObjectLiteral' => :object,
+        'ArrayLiteral'  => :array,
+        'New'           => :new,
+        'FunctionCall'  => :function_call,
+        'Import'        => :import,
+        'Export'        => :export,
+      }.each do |type,sym|
+        define_method(:"visit_#{type}") do |o|
+          [sym, o.value.map { |x| x.accept(self) }]
+        end
+      end
+
+      { 
+        'Name'    => :name,
+        'Number'  => :lit,
+        'Regexp'  => :lit,
+        'String'  => :str 
+      }.each do |type,sym|
+        define_method(:"visit_#{type}") do |o|
+          [sym, o.value]
+        end
+      end
+
+      {
+        'Break'     => :break,
+        'Continue'  => :continue,
+        'Null'      => :nil,
+        'True'      => :true,
+        'False'     => :false,
+        'This'      => :this,
+      }.each do |type,sym|
+        define_method(:"visit_#{type}") do |o|
+          [sym]
+        end
+      end
+
+      def visit_For(o)
+        [ :for,
+          o.init && o.init.accept(self),
+          o.cond && o.cond.accept(self),
+          o.update && o.update.accept(self),
+          o.body.accept(self)
+        ]
+      end
+
+      def visit_ForIn(o)
+        [ :for_in,
+          o.in_cond.accept(self),
+          o.body.accept(self)
+        ]
+      end
+
+      def visit_Try(o)
+        [ :try,
+          o.cond.accept(self),
+          o.b_then ? o.b_then.map { |x| x.accept(self) } : nil,
+          o.b_else ? o.b_else.accept(self) : nil
+        ]
+      end
+
+      {
+        'Ternary' => :ternary,
+        'If'      => :if,
+        'Catch'   => :catch,
+      }.each do |node,ident|
+        define_method(:"visit_#{node}") do |o|
+          [ ident,
+            o.cond.accept(self),
+            o.b_then ? o.b_then.accept(self) : nil,
+            o.b_else ? o.b_else.accept(self) : nil
+          ]
+        end
+      end
+      ### UNARY NODES ###
+      {
+        'Throw'             => :throw,
+        'Delete'            => :delete,
+        'Void'              => :void,
+        'Typeof'            => :typeof,
+        'PrefixDecrement'   => :prefix_dec,
+        'PostfixDecrement'  => :postfix_dec,
+        'PrefixIncrement'   => :prefix_inc,
+        'PostfixIncrement'  => :postfix_inc,
+        'Parenthesis'       => :paren,
+        'Return'            => :return,
+        'UnaryNegative'     => :u_neg,
+        'UnaryPositive'     => :u_pos,
+        'BitwiseNot'        => :bitwise_not,
+        'Not'               => :not,
+      }.each do |node,ident|
+        define_method(:"visit_#{node}") do |o|
+          [ident, o.value && o.value.accept(self)]
+        end
+      end
+
+      ### FUNCTION NODES ###
+      def visit_Function(o)
+        [:func_expr, o.name, o.arguments, o.body.accept(self)]
+      end
+
+      ### BINARY NODES ###
+      {
+        'In'                  => :in,
+        'InstanceOf'          => :instanceof,
+        'Switch'              => :switch,
+        'Case'                => :case,
+        'Default'             => :default,
+        'With'                => :with,
+        'DoWhile'             => :do_while,
+        'While'               => :while,
+        'Property'            => :property,
+        'GreaterThanOrEqual'  => :gt_equal,
+        'LessThanOrEqual'     => :lt_equal,
+        'GreaterThan'         => :gt,
+        'LessThan'            => :lt,
+        'GetterProperty'      => :getter,
+        'SetterProperty'      => :setter,
+        'OpEqual'             => :op_equal,
+        'OpMultiply'          => :op_multiply,
+        'OpMultiplyEqual'     => :op_multiply_equal,
+        'OpAddEqual'          => :op_add_equal,
+        'OpSubtractEqual'     => :op_subtract_equal,
+        'OpAdd'               => :op_add,
+        'OpSubtract'          => :op_subtract,
+        'OpDivideEqual'       => :op_divide_equal,
+        'OpDivide'            => :op_divide,
+        'OpLShiftEqual'       => :op_lshift_equal,
+        'OpRShiftEqual'       => :op_rshift_equal,
+        'OpURShiftEqual'      => :op_urshift_equal,
+        'OpLShift'            => :op_lshift,
+        'OpRShift'            => :op_rshift,
+        'OpURShift'           => :op_urshift,
+        'OpBitAndEqual'       => :op_bitand_equal,
+        'OpBitAnd'            => :op_bitand,
+        'OpBitXorEqual'       => :op_bitxor_equal,
+        'OpBitOrEqual'        => :op_bitor_equal,
+        'OpBitXor'            => :op_bitxor,
+        'OpBitOr'             => :op_bitor,
+        'OpModEqual'          => :op_mod_equal,
+        'OpMod'               => :op_mod,
+        'AssignExpr'          => :assign,
+        'BracketAccess'       => :bracket_access,
+        'DotAccessor'         => :dot_accessor,
+        'LexicalScope'        => :lexical_scope,
+        'Equal'               => :equal,
+        'NotEqual'            => :not_equal,
+        'Or'                  => :or,
+        'And'                 => :and,
+        'StrictEqual'         => :strict_equal,
+        'StrictNotEqual'      => :strict_not_equal,
+        'Label'               => :label,
+      }.each do |node,ident|
+        define_method(:"visit_#{node}") do |o|
+          [ident, o.left && o.left.accept(self), o.right &&o.right.accept(self)]
+        end
+      end
+
+      def accept(target)
+        target.accept(self)
+      end
+    end
+  end
+end

data/lib/johnson/visitors/visitor.rb

@@ -0,0 +1,91 @@
+module Johnson
+  module Visitors
+    class Visitor
+      def visit_SourceElements(o)
+        o.value.each { |x| x.accept(self) }
+      end
+
+      def visit_LexicalScope(o)
+        o.right.accept(self)
+      end
+
+      %w{
+        ArrayLiteral Comma Export FunctionCall Import New ObjectLiteral
+        VarStatement LetStatement
+      }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          o.value.each { |x| x.accept(self) }
+        end
+      end
+
+      %w{
+        Name Number Regexp String
+        Break Continue False Null This True
+      }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+        end
+      end
+
+      def visit_For(o)
+        o.init && o.init.accept(self)
+        o.cond && o.cond.accept(self)
+        o.update && o.update.accept(self)
+        o.body.accept(self)
+      end
+
+      def visit_ForIn(o)
+        o.in_cond.accept(self)
+        o.body.accept(self)
+      end
+
+      def visit_Try(o)
+        o.cond.accept(self)
+        o.b_then && o.b_then.map { |x| x.accept(self) }
+        o.b_else && o.b_else.accept(self)
+      end
+
+      %w{ Ternary If Catch }.each do |node|
+        define_method(:"visit_#{node}") do |o|
+          o.cond.accept(self)
+          o.b_then && o.b_then.accept(self)
+          o.b_else && o.b_else.accept(self)
+        end
+      end
+
+      ### UNARY NODES ###
+      %w{ BitwiseNot Delete Not Parenthesis PostfixDecrement PostfixIncrement
+        PrefixDecrement PrefixIncrement Return Throw Typeof UnaryNegative
+        UnaryPositive Void
+      }.each do |node|
+        define_method(:"visit_#{node}") do |o|
+          o.value && o.value.accept(self)
+        end
+      end
+
+      ### FUNCTION NODES ###
+      def visit_Function(o)
+        o.body.accept(self)
+      end
+
+      ### BINARY NODES ###
+      %w{ And AssignExpr BracketAccess Case Default DoWhile DotAccessor Equal
+        GetterProperty GreaterThan GreaterThanOrEqual In InstanceOf Label
+        LessThan 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 Switch While With
+      }.each do |node|
+        define_method(:"visit_#{node}") do |o|
+          o.left && o.left.accept(self)
+          o.right && o.right.accept(self)
+        end
+      end
+
+      def accept(target)
+        target.accept(self)
+      end
+    end
+  end
+end

data/lib/rails/init.rb

@@ -0,0 +1,37 @@
+require 'johnson'
+
+class EJSHandler < ActionView::TemplateHandler
+  class EJSProxy # :nodoc:
+    def initialize(controller)
+      @controller = controller
+    end
+
+    def key?(pooperty)
+      @controller.instance_variables.include?("@#{pooperty}")
+    end
+
+    def [](pooperty)
+      @controller.instance_variable_get("@#{pooperty}")
+    end
+
+    def []=(pooperty, value)
+      @controller.instance_variable_set("@#{pooperty}", value)
+    end
+  end
+
+  def initialize(view)
+    @view = view
+  end
+
+  def render(template)
+    ctx = Johnson::Runtime.new
+    ctx.evaluate('Johnson.require("johnson/template");')
+    ctx['template'] = template.source
+    ctx['controller'] = @view.controller
+    ctx['at'] = EJSProxy.new(@view.controller)
+
+    ctx.evaluate('Johnson.templatize(template).call(at)')
+  end
+end
+
+ActionView::Template.register_template_handler("ejs", EJSHandler)

data/lib/tasks/gem.rake

@@ -0,0 +1,9 @@
+namespace :gem do
+  "Generate a VERSION.timestamp gemspec."
+  task :spec do
+    File.open("#{HOE.name}.gemspec", "w") do |f|
+      HOE.spec.version = "#{HOE.version}.#{Time.now.strftime("%Y%m%d%H%M%S")}"
+      f.puts(HOE.spec.to_ruby)
+    end
+  end
+end

data/lib/tasks/parsing.rake

@@ -0,0 +1,37 @@
+require "erb"
+
+GENERATED_NODE = "ext/spidermonkey/immutable_node.c"
+HOE.clean_globs << GENERATED_NODE
+task :check_manifest => GENERATED_NODE
+
+def jsops
+  ops = []
+  File.open("vendor/spidermonkey/jsopcode.tbl", "rb") { |f|
+    f.each_line do |line|
+      if line =~ /^OPDEF\((\w+),/
+        ops << $1
+      end
+    end
+  }
+  ops
+end
+
+def tokens
+  toks = []
+  File.open("vendor/spidermonkey/jsscan.h", "rb") { |f|
+    f.each_line do |line|
+      line.scan(/TOK_\w+/).each do |token|
+        next if token == "TOK_ERROR"
+        toks << token
+      end
+    end
+  }
+  toks.uniq
+end
+
+file GENERATED_NODE => "ext/spidermonkey/immutable_node.c.erb"  do |t|
+  template = ERB.new(File.open(t.prerequisites.first, "rb") { |x| x.read })
+  File.open(GENERATED_NODE, "wb") { |f| f.write template.result(binding) }
+end
+
+file "ext/spidermonkey/extconf.rb" => GENERATED_NODE

data/lib/tasks/testing.rake

@@ -0,0 +1,36 @@
+namespace :test do
+  # partial-loads-ok and undef-value-errors necessary to ignore
+  # spurious (and eminently ignorable) warnings from the ruby
+  # interpreter
+  VALGRIND_BASIC_OPTS = "--num-callers=50 --error-limit=no --partial-loads-ok=yes --undef-value-errors=no"
+
+  desc "run test suite under valgrind with basic ruby options"
+  task :valgrind => :compile do
+    cmdline = "valgrind #{VALGRIND_BASIC_OPTS} ruby #{HOE.make_test_cmd}"
+    puts cmdline
+    system cmdline
+  end
+
+  desc "run test suite under valgrind with memory-fill ruby options"
+  task :valgrind_mem => :compile do
+    # fill malloced memory with "m" and freed memory with "f"
+    cmdline = "valgrind #{VALGRIND_BASIC_OPTS} --freelist-vol=100000000 --malloc-fill=6D --free-fill=66 ruby #{HOE.make_test_cmd}"
+    puts cmdline
+    system cmdline
+  end
+
+  desc "run test suite under valgrind with memory-zero ruby options"
+  task :valgrind_mem0 => :compile do
+    # fill malloced and freed memory with 0
+    cmdline = "valgrind #{VALGRIND_BASIC_OPTS} --freelist-vol=100000000 --malloc-fill=00 --free-fill=00 ruby #{HOE.make_test_cmd}"
+    puts cmdline
+    system cmdline
+  end
+
+  desc "run test suite under gdb"
+  task :gdb => :compile do
+    cmdline = "gdb --args ruby #{HOE.make_test_cmd}"
+    puts cmdline
+    system cmdline
+  end
+end

data/lib/tasks/vendor.rake

@@ -0,0 +1,20 @@
+namespace :vendor do
+  namespace :spidermonkey do
+    desc "Clean the vendored SpiderMonkey."
+    task :clean do
+      Dir.chdir "vendor/spidermonkey" do
+        sh "make clean -f Makefile.ref" unless Dir["**/libjs.a"].empty?
+      end
+    end
+
+    desc "Compile the vendored SpiderMonkey."
+    task :compile do
+      Dir.chdir "vendor/spidermonkey" do
+        sh "make -f Makefile.ref" if Dir["**/libjs.a"].empty?
+      end
+    end
+  end
+end
+
+task :clean                        => "vendor:spidermonkey:clean"
+file "ext/spidermonkey/extconf.rb" => "vendor:spidermonkey:compile"

data/test/helper.rb

@@ -0,0 +1,55 @@
+require "rubygems"
+require "test/unit"
+
+%w(../lib ../ext/spidermonkey).each do |path|
+  $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), path)))
+end
+
+require "johnson"
+
+module Johnson
+  class TestCase < Test::Unit::TestCase
+    class TestLogger
+      def debug(string)
+        puts string
+      end
+    end
+
+    undef :default_test if method_defined? :default_test
+
+    def setup
+      @runtime = Johnson::Runtime.new
+      #@runtime.delegate.gc_zeal = 2
+      #@runtime.delegate.debugger = Johnson::SpiderMonkey::Debugger.new(TestLogger.new)
+    end
+    
+    def assert_js(expression, options={})
+      runtime = options[:runtime] || @runtime
+      assert(runtime.evaluate(expression), "Expected JS expression [#{expression}] to be true.")
+    end
+    
+    def assert_js_equal(expected, expression, options={})
+      runtime = options.delete(:runtime) || @runtime
+      options.each { |k, v| runtime[k.to_s] = v }
+      assert_equal(expected, runtime.evaluate(expression))
+    end
+  end
+
+  class NodeTestCase < Test::Unit::TestCase
+    include Johnson::Nodes
+  
+    undef :default_test if method_defined? :default_test
+    
+    def setup
+      @parser = Johnson::Parser
+    end
+  
+    def assert_sexp(expected, actual)
+      assert_equal(expected, actual.to_sexp)
+    end
+
+    def assert_ecma(expected, actual)
+      assert_equal(expected, actual.to_ecma)
+    end
+  end
+end