opal 0.3.6 → 0.3.9

data/lib/opal/command.rb

@@ -0,0 +1,52 @@
+module Opal
+
+  class Command
+
+    # Valid command line arguments
+    COMMANDS = [:help, :irb, :compile, :bundle, :exec, :eval]
+
+    def initialize(args)
+      command = args.shift
+
+      if command and COMMANDS.include?(command.to_sym)
+        __send__ command.to_sym, *args
+      elsif command and File.exists? command
+        eval command
+      else
+        help
+      end
+    end
+
+    def help
+      puts "need to print help"
+    end
+
+    # desc "irb", "Opens interactive opal/ruby repl"
+    def irb
+      ctx = Opal::Context.new
+      ctx.start_repl
+    end
+
+    def eval(path = nil)
+      return "no path given for eval" unless path
+
+      abort "path does not exist `#{path}'" unless File.exist? path
+
+      ctx = Opal::Context.new
+      ctx.require_file File.expand_path(path)
+    end
+
+    def compile(path)
+      puts Opal::Parser.new(File.read(path)).parse!.generate_top
+    end
+
+    # desc "bundle", "Bundle the gem in the given directory ready for browser"
+    # method_options :out => :string
+    def bundle
+      opts = options
+      bundle = Opal::Bundle.new(Opal::Gem.new(Dir.getwd))
+      bundle.build opts
+    end
+  end
+end
+

data/lib/opal/context.rb

@@ -0,0 +1,197 @@
+module Opal
+  class Context
+
+    def initialize(root_dir = Dir.getwd)
+      @root_dir = root_dir
+      @builder = Opal::Builder.new
+
+      @load_paths = resolve_load_paths
+    end
+
+    # Looks through vendor/ directory and adds all relevant load paths
+    def resolve_load_paths
+      Dir['vendor/*/package.yml'].map do |package|
+        File.expand_path File.join(File.dirname(package), 'lib')
+      end
+    end
+
+    # Setup the context. This basically loads opal.js into our context, and
+    # replace the loader etc with our custom loader for a Ruby environment. The
+    # default "browser" loader cannot access files from disk.
+    def setup_v8
+      return if @v8
+
+      begin
+        require 'v8'
+      rescue LoadError => e
+        abort "therubyracer is required for running javascript. Install it with `gem install therubyracer`"
+      end
+
+      @v8 = V8::Context.new
+      @v8['console'] = Console.new
+
+      eval @builder.build_core, '(opal)'
+      opal = @v8['opal']
+      opal['fs'] = FileSystem.new self
+
+      # FIXME: we cant use a ruby array as a js array :(
+      opal['loader'] = Loader.new self, eval("[]")
+
+      @load_paths.each do |path|
+        eval "opal.loader.paths.push('#{path}')"
+      end
+
+    end
+
+    def eval(code, file = nil)
+      @v8.eval code, file
+    end
+
+    # Require the given id as if it was required in the context. This simply
+    # passes the require through to the underlying context.
+    def require_file(path)
+      setup_v8
+      eval "opal.run(function() {opal.require('#{path}');});", path
+      finish
+    end
+
+    # Set ARGV for the context
+    def argv=(args)
+      puts "setting argv to #{args.inspect}"
+      eval "opal.runtime.cs(opal.runtime.Object, 'ARGV', #{args.inspect});"
+    end
+
+    # Start normal js repl
+    def start_repl
+      require 'readline'
+      setup_v8
+
+      loop do
+        # on SIGINT lets just return from the loop..
+        trap("SIGINT") { finish; return }
+        line = Readline.readline '>> ', true
+
+        # if we type exit, then we need to close down context
+        if line == "exit"
+          break
+        end
+
+        puts "=> #{eval_ruby line, '(opal)'}"
+      end
+
+      finish
+    end
+
+    def eval_ruby(content, line = "")
+      begin
+        code = Opal::Parser.new(content).parse!.generate_top
+        code = "opal.run(function() {var $rb = opal.runtime, self = $rb.top, __FILE__ = '(opal)';" + code + "});"
+        # puts code
+        @v8['$opal_irb_result'] = eval code, line
+        eval "!($opal_irb_result == null || !$opal_irb_result.m$inspect) ? $opal_irb_result.m$inspect() : '(Object does not support #inspect)'"
+      rescue => e
+        puts e
+        puts("\t" + e.backtrace.join("\n\t"))
+      end
+    end
+
+    # Finishes the context, i.e. tidy everything up. This will cause
+    # the opal runtime to do it's at_exit() calls (if applicable) and
+    # then the v8 context will de removed. It can be reset by calling
+    # #setup_v8
+    def finish
+      return unless @v8
+      eval "opal.runtime.do_at_exit()", "(opal)"
+
+      @v8 = nil
+    end
+
+    # Console class is used to mimic the console object in web browsers
+    # to allow simple debugging to the stdout.
+    class Console
+      def log(*str)
+        puts str.join("\n")
+        nil
+      end
+    end
+
+    # FileSystem is used to interact with the file system from the ruby
+    # version of opal. The methods on this class replace the default ones
+    # made available in the web browser.
+    class FileSystem
+
+      def initialize(context)
+        @context = context
+      end
+
+      def cwd
+        Dir.getwd
+      end
+
+      def glob(*arr)
+        Dir.glob arr
+      end
+
+      def exist_p(path)
+        File.exist? path
+      end
+
+      def expand_path(filename, dir_string = nil)
+        File.expand_path filename, dir_string
+      end
+
+      def dirname(file)
+        File.dirname file
+      end
+
+      def join(*parts)
+        File.join *parts
+      end
+    end
+
+    # Loader for v8 context
+    class Loader
+
+      attr_reader :paths
+
+      def initialize(context, paths)
+        @context = context
+        @paths = paths
+      end
+
+      def resolve_lib(id)
+        resolved = find_lib id
+        raise "Cannot find lib `#{id}'" unless resolved
+
+        resolved
+      end
+
+      def find_lib(id)
+        @paths.each do |path|
+          candidate = File.join path, "#{id}.rb"
+          return candidate if File.exists? candidate
+
+          candidate = File.join path, id
+          return candidate if File.exists? candidate
+        end
+
+        return File.expand_path id if File.exists? id
+        return File.expand_path(id + '.rb') if File.exists?(id + '.rb')
+
+        nil
+      end
+
+      def ruby_file_contents(filename)
+        Opal::Parser.new(File.read(filename)).parse!.generate_top
+      end
+
+      def wrap(content, filename)
+        code = "(function($rb, self, __FILE__) { #{content} });"
+        @context.eval code, filename
+        # code
+      end
+    end
+
+  end
+end
+

data/{opal_lib/opal/ruby/parser.rb → lib/opal/lexer.rb}

@@ -1,11 +1,12 @@
 
-require 'opal/ruby/ruby_parser'
-require 'opal/ruby/nodes'
+require 'opal/parser'
+require 'opal/nodes'
+
 
 require 'strscan'
 
 module Opal
-  class RubyParser < Racc::Parser
+  class Parser < Racc::Parser
 
   class RubyLexingError < StandardError
 
@@ -29,7 +30,6 @@ module Opal
 
   def next_token
     t = get_next_token
-    # puts "returning token #{t.inspect}"
     t[1] = { :value => t[1], :line => @line_number }
     t
   end
@@ -725,6 +725,14 @@ module Opal
           @lex_state = :expr_end
           return :NIL, scanner.matched
 
+        when 'undefined'
+          @lex_state = :expr_end
+          return :UNDEFINED, scanner.matched
+
+        when 'null'
+          @lex_state = :expr_end
+          return :NULL, scanner.matched
+
         when '__LINE__'
           @lex_state = :expr_end
           return :LINE, @line_number.to_s
@@ -809,6 +817,14 @@ module Opal
           @lex_state = :expr_beg
           return :WHILE_MOD, scanner.matched
 
+        when 'for'
+          @lex_state = :expr_beg
+          return :FOR, scanner.matched
+
+        when 'in'
+          @lex_state = :expr_beg
+          return :IN, scanner.matched
+
         when 'until'
           return :WHILE, scanner.matched if @lex_state == :expr_beg
           @lex_state = :expr_beg

data/{opal_lib/opal/ruby → lib/opal}/nodes.rb

@@ -1,5 +1,5 @@
 module Opal
-  class RubyParser < Racc::Parser
+  class Parser < Racc::Parser
 
   # Indent for generated code scopes; 2 spaces, never use tabs
   INDENT = '  '
@@ -8,6 +8,7 @@ module Opal
   LEVEL_TOP_CLOSURE   = 1 # normal top level, but wrapped in js closure
   LEVEL_LIST          = 2
   LEVEL_EXPR          = 3
+  LEVEL_COMPARE       = 4 # comparison of if statement etc
 
   # Base node for generators. All other nodes inherit from this
   class BaseNode
@@ -69,6 +70,27 @@ module Opal
 
       code
     end
+
+    # Reserved js words - we cannot just generate properties with these names
+    # as they will cause a parse error, so we need to wrap them in brackets.
+    def js_reserved_words
+      %w[break case catch continue debugger default delete do else finally
+         for function if in instanceof new return switch this throw try typeof
+         var void while with class enum export extends import super true false]
+    end
+
+    def generate_truthy_test(expr, opts)
+      if expr.is_a? ComparisonNode
+        expr.generate opts, LEVEL_EXPR
+      else
+        tmp = opts[:scope].temp_local
+        code = expr.generate opts, LEVEL_EXPR
+        res = "(#{tmp} = #{code}, #{tmp} !== false && #{tmp} !== nil)"
+        opts[:scope].queue_temp tmp
+        res
+      end
+    end
+
   end
 
   # Scope nodes. All scope nodes inherit from this node, including: method,
@@ -194,26 +216,6 @@ module Opal
       super nil, statements
       @file_helpers = []
       @line = 1
-      @mm_ids = []
-
-      @symbol_refs = {}
-      @symbol_count = 1
-
-      @regexp_refs = []
-    end
-
-    def register_mm_id(mid)
-      @mm_ids << mid unless @mm_ids.include? mid
-    end
-
-    def register_symbol(sym)
-      if ref = @symbol_refs[sym]
-        ref
-      else
-        ref = @symbol_refs[sym] = "$symbol_#{@symbol_count}"
-        @symbol_count += 1
-        ref
-      end
     end
 
     def generate(opts, level)
@@ -225,32 +227,26 @@ module Opal
 
       pre = 'function $$(){'
       post = "\n}\n"
-      # post = "\n\n}\nvar nil, $ac, $super, $break, $class, $def, $symbol, $range, "
-      # post += '$hash, $B, Qtrue, Qfalse, $cg;'
-      # local vars... only if we used any..
+
       unless @scope_vars.empty?
         post += "var #{@scope_vars.join ', '};"
       end
 
-      post += 'var nil = $rb.Qnil, $ac = $rb.ac, $super = $rb.S, $break = $rb.B, '
-      post += '$class = $rb.dc, $defn = $rb.dm, $defs = $rb.ds, $symbol = $rb.Y, '
-      post += '$hash = $rb.H, $B = $rb.P, Qtrue = $rb.Qtrue, Qfalse = $rb.Qfalse, '
-      post += '$cg = $rb.cg, $range = $rb.G'
-
-      # symbols
-      @symbol_refs.each do |val, sym|
-        post += ", #{sym} = $symbol('#{val}')"
-      end
+      post += 'var nil = $rb.Qnil, $super = $rb.S, $break = $rb.B, '
+      post += '$class = $rb.dc, $defn = $rb.dm, $defs = $rb.ds, $cg = $rb.cg, '
+      post += '$range = $rb.G, $hash = $rb.H, $B = $rb.P'
 
       post += ';'
 
-      if @mm_ids.length > 0
-        post += "$rb.mm(['#{ @mm_ids.join "', '" }']);"
-      end
-
       # ivars
       @ivars.each do |ivar|
-        post += "if (self['#{ivar}'] == undefined) { self['#{ivar}'] = nil; }"
+        if js_reserved_words.include? ivar
+          ivar_name = "self['#{ivar}']"
+        else
+          ivar_name = "self.#{ivar}"
+        end
+
+        post += "#{ivar_name}===undefined&&(#{ivar_name}=nil);"
       end
 
       post += "return $$();\n"
@@ -348,7 +344,7 @@ module Opal
     end
 
     def generate(opts, level)
-      opts[:top].register_symbol @value
+      "'#{@value}'"
     end
   end
 
@@ -369,20 +365,10 @@ module Opal
     end
 
     def mid_to_jsid(id)
-      return ".$m['#{id}']" if /[\!\=\?\+\-\*\/\^\&\%\@\|\[\]\<\>\~]/ =~ id
-
-      return ".$m['#{id}']" if js_reserved_words.include? id
+      return "['#{id}']" if /[\!\=\?\+\-\*\/\^\&\%\@\|\[\]\<\>\~]/ =~ id
 
       # default we just do .method_name
-      '.$m.' + id
-    end
-
-    # Reserved js words - we cannot just generate properties with these names
-    # as they will cause a parse error, so we need to wrap them in brackets.
-    def js_reserved_words
-      %w[break case catch continue debugger default delete do else finally
-         for function if in instanceof new return switch this throw try typeof
-         var void while with class enum export extends import super]
+      '.' + id
     end
 
     def generate(opts, level)
@@ -393,16 +379,13 @@ module Opal
 
       elsif @mid == "block_given?"
         # name = opts[:scope].set_uses_block
-        return "($yy == $y.y ? Qfalse : Qtrue)"
+        return "($yy !== $y.y)"
       end
 
       code = ''
       arg_res = []
       recv = nil
-      mid = @mid
-      tmp_recv = opts[:scope].temp_local
-
-      opts[:top].register_mm_id @mid
+      mid = 'm$' + @mid
 
       # receiver
       if @recv.is_a? NumericNode
@@ -410,25 +393,11 @@ module Opal
       elsif @recv
         recv = @recv.process opts, LEVEL_EXPR
       else
-        @recv = SelfNode.new
         recv = "self"
-        mid = '$' + mid
       end
 
       mid = mid_to_jsid(mid)
 
-      if @recv.is_a? SelfNode
-        recv_code = recv
-        recv_arg = recv
-      elsif @recv.is_a?(IdentifierNode) and @recv.local_variable?(opts)
-        recv_code = recv
-        recv_arg = recv
-      else
-        recv_code = "(#{tmp_recv} = #{recv})"
-        recv_arg = "#{tmp_recv}"
-      end
-
-
       args = @args
       # normal args
       if args[0]
@@ -443,11 +412,12 @@ module Opal
       end
 
       if @block
+        tmp_recv = opts[:scope].temp_local
         block = @block.generate opts, LEVEL_TOP
-        arg_res.unshift recv_arg
+        arg_res.unshift tmp_recv
 
-        code = "($B.f = #{recv_code}#{mid}, ($B.p ="
-        code += "#{block}).$proc =[self], $B.f)(#{arg_res.join ', '})"
+        code = "(#{tmp_recv} = #{recv}, $B.f = #{tmp_recv}#{mid}, ($B.p ="
+        code += "#{block}).$self=self, $B.f).call(#{arg_res.join ', '})"
 
         opts[:scope].queue_temp tmp_recv
         code
@@ -457,10 +427,11 @@ module Opal
       #
       # FIXME need to actually call to_proc.
       elsif args[3]
-        arg_res.unshift recv_arg
+        tmp_recv = opts[:scope].temp_local
+        arg_res.unshift tmp_recv
 
         code = "($B.p = #{args[3].process opts, LEVEL_LIST}, "
-        code += "$B.f = #{recv_code}#{mid})(#{arg_res.join ', '})"
+        code += "$B.f = (#{tmp_recv} = #{recv})#{mid}).call(#{arg_res.join ', '})"
 
         opts[:scope].queue_temp tmp_recv
 
@@ -470,21 +441,18 @@ module Opal
       else
         # splat args
         if args[1]
-          arg_res.unshift recv_arg
+          tmp_recv = opts[:scope].temp_local
           splat = args[1].generate(opts, LEVEL_EXPR)
           splat_args = arg_res.empty? ? "#{splat}" : "[#{arg_res.join ', '}].concat(#{splat})"
           # when using splat, our this val for apply may need a tmp var
           # to save just outputting it twice (have to follow recv path twice)
           splat_recv = recv
-          result = "#{recv_code}" + mid + ".apply(nil, #{splat_args})"
+          result = "(#{tmp_recv} = #{recv})" + mid + ".apply(#{tmp_recv}, #{splat_args})"
 
           opts[:scope].queue_temp tmp_recv
           result
         else
-          arg_res.unshift recv_arg
-
-          result = "#{recv_code}#{mid}(#{arg_res.join(', ')})"
-          opts[:scope].queue_temp tmp_recv
+          result = "#{recv}#{mid}(#{arg_res.join(', ')})"
           result
         end
       end
@@ -514,6 +482,28 @@ module Opal
     end
   end
 
+  class UndefinedNode < BaseNode
+
+    def initialize(val)
+      @line = val[:line]
+    end
+
+    def generate(opts, level)
+      'undefined'
+    end
+  end
+
+  class NullNode < BaseNode
+
+    def initialize(val)
+      @line = val[:line]
+    end
+
+    def generate(opts, level)
+      'null'
+    end
+  end
+
   class ModuleNode < ScopeNode
 
     def initialize(mod, path, body, _end)
@@ -688,7 +678,13 @@ module Opal
         args[1].each do |arg|
           param_variable arg[0][:value]
           method_args << arg[0][:value]
-          pre_code += "if (#{arg[0][:value]} == undefined) {#{arg[0][:value]} = #{arg[1].generate(opts, LEVEL_EXPR)};}"
+
+          # undefined is a special case... we use it to make core libs have
+          # right arity, but we dont want overhead of checking for no arg.
+          # i.e. non given arg will be undefined, not nil..
+          unless arg[1].is_a? UndefinedNode
+            pre_code += "if (#{arg[0][:value]} == undefined) {#{arg[0][:value]} = #{arg[1].generate(opts, LEVEL_EXPR)};}"
+          end
         end
       end
 
@@ -697,10 +693,11 @@ module Opal
         if args[2][:value] != "*"
           param_variable args[2][:value]
           method_args << args[2][:value]
-          pre_code += "#{args[2][:value]} = [].slice.call(arguments, #{method_args.length});"
+          pre_code += "#{args[2][:value]} = [].slice.call(arguments, #{method_args.length - 1});"
         end
       end
 
+      # arity not currently used..could use it for debug mode?
       arity = (-arity) - 1 if args[1] or args[2]
 
       # block arg
@@ -712,9 +709,8 @@ module Opal
 
       @body.returns
       stmt = @body.generate scope, LEVEL_TOP
-      method_args.unshift 'self'
 
-      code += "function(#{method_args.join ', '}) {"
+      code += "function(#{method_args.join ', '}) { var self = this;"
 
       # local vars... only if we used any..
       unless @scope_vars.empty?
@@ -723,7 +719,13 @@ module Opal
 
       # ivars
       @ivars.each do |ivar|
-        pre_code += "self['#{ivar}']==undefined&&(self['#{ivar}']=nil);"
+        if js_reserved_words.include? ivar
+          ivar_name = "self['#{ivar}']"
+        else
+          ivar_name = "self.#{ivar}"
+        end
+
+        pre_code += "if (#{ivar_name} == undefined) { #{ivar_name} = nil; }"
       end
 
       # block support
@@ -732,14 +734,14 @@ module Opal
         block_code = "var $y = $B, $yy, $ys, $yb = $y.b;"
         block_code += "if ($y.f == arguments.callee) { $yy = $y.p; }"
         block_code += "else { $yy = $y.y; }"
-        block_code += "$y.f = nil ;$ys = $yy.$proc[0];"
+        block_code += "$y.f = nil ;$ys = $yy.$self;"
         pre_code = block_code + pre_code
       end
 
       code += (pre_code + stmt)
 
       # fix trailing end and 0/1 for normal/singleton
-      code += (fix_line_number(opts, @end_line) + "}, #{arity})")
+      code += (fix_line_number(opts, @end_line) + "})")
 
       code
     end
@@ -748,6 +750,7 @@ module Opal
   class BodyStatementsNode < BaseNode
 
     attr_reader :opt_rescue
+    attr_reader :opt_ensure
 
     def initialize(stmt, optrescue, optelse, optensure)
       @statements = stmt
@@ -777,7 +780,7 @@ module Opal
     def generate(opts, level)
       res = '(('
       tmp = opts[:scope].temp_local
-      res += "#{tmp} = #{@lhs.generate opts, LEVEL_LIST}).$r ? "
+      res += "(#{tmp} = #{@lhs.generate opts, LEVEL_LIST}), #{tmp} != false && #{tmp} != nil) ? "
       res += "#{tmp} : #{@rhs.generate opts, LEVEL_LIST})"
       opts[:scope].queue_temp tmp
       res
@@ -795,7 +798,7 @@ module Opal
     def generate(opts, level)
       res = '(('
       tmp = opts[:scope].temp_local
-      res += "#{tmp} = #{@lhs.generate opts, LEVEL_LIST}).$r ? "
+      res += "(#{tmp} = #{@lhs.generate opts, LEVEL_LIST}), #{tmp} != false && #{tmp} != nil) ? "
       res += "#{@rhs.generate opts, LEVEL_LIST} : #{tmp})"
       opts[:scope].queue_temp tmp
       res
@@ -822,7 +825,7 @@ module Opal
         res = code
       end
 
-      res
+      "#{res}"
     end
   end
 
@@ -884,20 +887,18 @@ module Opal
         @level_expr = true
       end
 
-      expr = @expr.generate opts, LEVEL_EXPR
-      expr = "(#{expr})" if @expr.is_a? NumericNode
-
+      expr = generate_truthy_test @expr, opts
       # code += "if ((#{@expr.generate opts, LEVEL_EXPR}).$r) {#{@stmt.process opts, stmt_level}"
-      code += "if (#{@type == 'if' ? '' : '!'}#{expr}.$r) {#{@stmt.process opts, stmt_level}"
+      code += "if (#{@type == 'if' ? '' : '!'}#{expr}) {#{@stmt.process opts, stmt_level}"
 
       @tail.each do |tail|
         opts[:indent] = old_indent
         code = code + fix_line_number(opts, tail[0][:line])
 
         if tail[0][:value] == 'elsif'
-          expr = tail[1].generate opts, LEVEL_EXPR
-          expr = "(#{expr})" if tail[1].is_a? NumericNode
-          code += "} else if (#{expr}.$r) {"
+          expr = generate_truthy_test tail[1], opts
+
+          code += "} else if (#{expr}) {"
           # code += "} else if ((#{tail[1].generate opts, LEVEL_EXPR}).$r) {"
           opts[:indent] = opts[:indent] + INDENT
           code = code + tail[2].process(opts, stmt_level)
@@ -971,10 +972,10 @@ module Opal
         if part[0][:value] == 'when'
           code += (idx == 0 ? "if" : "} else if")
           parts = part[1].map do |expr|
-            CallNode.new(expr,
+            generate_truthy_test CallNode.new(expr,
                         {:value => '===' },
                         [[TempNode.new(case_ref)]]
-            ).generate(opts, LEVEL_EXPR) + '.$r'
+            ), opts
           end
           opts[:indent] = opts[:indent] + INDENT
           code += " (#{parts.join ' || '}) {#{part[2].process opts, stmt_level}"
@@ -988,7 +989,7 @@ module Opal
       opts[:scope].queue_temp case_ref
       code += (fix_line_number(opts, @end_line) + '}')
 
-      code = "(function() {#{code})()" if level == LEVEL_EXPR
+      code = "(function() {#{code}})()" if level == LEVEL_EXPR
       code
     end
   end
@@ -1057,7 +1058,14 @@ module Opal
 
     def generate(opts, level)
       if @lhs.is_a? IvarNode
-        return "#{SelfNode.new.generate(opts, level)}['#{@lhs.value}'] = #{@rhs.generate(opts, LEVEL_EXPR)}"
+        ivar_name = @lhs.value.slice 1, @lhs.value.length
+        ivar_rhs = @rhs.generate opts, LEVEL_EXPR
+
+        return "self['#{ivar_name}'] = #{ivar_rhs}" if js_reserved_words.include? ivar_name
+        return "self.#{ivar_name} = #{ivar_rhs}"
+
+      elsif @lhs.is_a? CvarNode
+        return "$rb.cvs('#{@lhs.value}', #{@rhs.generate opts, LEVEL_EXPR})"
 
       elsif @lhs.is_a? GvarNode
         return "$rb.gs('#{@lhs.value}', #{@rhs.generate(opts, LEVEL_EXPR)})"
@@ -1167,8 +1175,25 @@ module Opal
     end
 
     def generate(opts, level)
-      opts[:scope].ensure_ivar @value
-      "#{SelfNode.new.generate(opts, level)}['#{@value}']"
+      var_name = @value.slice 1, @value.length
+      opts[:scope].ensure_ivar var_name
+
+      return "self['#{var_name}']" if js_reserved_words.include? var_name
+      "self.#{var_name}"
+    end
+  end
+
+  class CvarNode < BaseNode
+
+    attr_reader :value
+
+    def initialize(val)
+      @line = val[:line]
+      @value = val[:value]
+    end
+
+    def generate(opts, level)
+      "$rb.cvg('#{@value}')"
     end
   end
 
@@ -1228,7 +1253,8 @@ module Opal
           if part[0] == 'string_content'
             @join + part[1][:value] + @join
           elsif part[0] == 'string_dbegin'
-            CallNode.new(part[1], { :value => 'to_s', :line => 0 }, [[]]).generate(opts, level)
+            "(" + part[1].generate(opts, LEVEL_EXPR) + ").m$to_s()"
+            # CallNode.new(part[1], { :value => 'to_s', :line => 0 }, [[]]).generate(opts, level)
           end
         end
 
@@ -1237,6 +1263,49 @@ module Opal
     end
   end
 
+  class ComparisonNode < BaseNode
+
+    def initialize(op, lhs, rhs)
+      @line = op[:line]
+      @op = op[:value]
+      @lhs = lhs
+      @rhs = rhs
+    end
+
+    def generate(opts, level)
+      lhs = @lhs.generate opts, LEVEL_EXPR
+      lhs = "(#{lhs})" if @lhs.is_a? NumericNode
+      rhs = @rhs.generate opts, LEVEL_EXPR
+
+      if @op == '!='
+        "!#{lhs}['m$=='](#{rhs})"
+      else
+        "#{lhs}['m$#{@op}'](#{rhs})"
+      end
+    end
+  end
+
+  class UnaryNode < BaseNode
+
+    def initialize(op, val)
+      @line = op[:line]
+      @op = op[:value]
+      @val = val
+    end
+
+    def generate(opts, level)
+      if @op == '!'
+        tmp = opts[:scope].temp_local
+        expr = @val.generate opts, LEVEL_EXPR
+        res = "(#{tmp} = #{expr}, #{tmp} === false || #{tmp} === nil)"
+        opts[:scope].queue_temp tmp
+        res
+      else
+        "#{@op}#{@val.generate opts, level}"
+      end
+    end
+  end
+
   class TrueNode < BaseNode
 
     def initialize(val)
@@ -1244,7 +1313,7 @@ module Opal
     end
 
     def generate(opts, level)
-      "Qtrue"
+      "true"
     end
   end
 
@@ -1255,7 +1324,7 @@ module Opal
     end
 
     def generate(opts, level)
-      "Qfalse"
+      "false"
     end
   end
 
@@ -1293,7 +1362,7 @@ module Opal
             #
             # Also, this is optional, and can be turned on/off for
             # performance gains.
-            if true
+            if false
               pre_code += "if (#{arg[:value]} === undefined) { #{arg[:value]} = nil; }"
             end
           end
@@ -1317,7 +1386,7 @@ module Opal
           # FIXME if we just pass '*', then we make a tmp variable name for it..
           param_variable rest_arg_name
           method_args << rest_arg_name
-          pre_code += "#{rest_arg_name} = [].slice.call($A, #{method_args.length});"
+          pre_code += "#{rest_arg_name} = [].slice.call(arguments, #{method_args.length - 1});"
           end
         end
 
@@ -1325,17 +1394,17 @@ module Opal
         if args[3]
           param_variable args[3][:value]
           @block_arg_name = args[3][:value]
+          pre_code += "var #{args[3][:value]} = (($yy == $y.y) ? nil: $yy);"
         end
       end
 
       @stmt.returns
       stmt = @stmt.process scope, LEVEL_TOP
-      method_args.unshift 'self'
 
       block_var = opts[:scope].temp_local
       # code += "(#{block_var} = "
 
-      code += "function(#{method_args.join ', '}) {"
+      code += "function(#{method_args.join ', '}) { var self = this;"
 
       unless @scope_vars.empty?
         code += " var #{@scope_vars.join ', '};"
@@ -1343,15 +1412,11 @@ module Opal
 
       # block arg
       if @block_arg_name
-          pre_code += "var $yield, #@block_arg_name; if ($B.f == arguments.callee && $B.p != nil) { #@block_arg_name = "
-          pre_code += "$yield = $B.p; } else { #@block_arg_name = nil; "
-          pre_code += "$yield = $B.y; } $B.p = $B.f = nil;"
-          pre_code += "var $yself = $yield.$proc[0];"
-
-          stmt = "try{" + stmt
-
-          # catch break statements
-          stmt += "} catch (__err__) {if(__err__.$keyword == 2) {return __err__.$value;} throw __err__;}"
+        block_code = "var $y = $B, $yy, $ys, $yb = $y.b;"
+        block_code += "if ($y.f == arguments.callee) { $yy = $y.p; }"
+        block_code += "else { $yy = $y.y; }"
+        block_code += "$y.f = nil ;$ys = $yy.o$s;"
+        pre_code = block_code + pre_code
       end
 
       code += (pre_code + stmt + fix_line_number(opts, @end_line) + "}")
@@ -1471,8 +1536,10 @@ module Opal
       # if we return, make sure our stmt does
       @stmt.returns if @returns
 
-      r = "if(#{@type == 'if' ? '' : '!'}(#{@expr.generate(opts, LEVEL_EXPR)}"
-      r += ").$r) {#{@stmt.process(opts, LEVEL_TOP)}}"
+      expr = generate_truthy_test @expr, opts
+
+      r = "if(#{@type == 'if' ? '' : '!'}(#{expr}"
+      r += ")) {#{@stmt.process(opts, LEVEL_TOP)}}"
 
       # also, if we return, we need to ensure we have an else conditional
       r += " else { return nil; }" if @returns
@@ -1499,10 +1566,10 @@ module Opal
 
       if @args[1]
         parts.unshift '$ys'
-        code = "#{block_code}(null, [#{parts.join ', '}].concat(#{@args[1].generate(opts, LEVEL_EXPR)}))"
+        code = "#{block_code}.apply($ys, [#{parts.join ', '}].concat(#{@args[1].generate(opts, LEVEL_EXPR)}))"
       else
         parts.unshift '$ys'
-        code = "#{block_code}(#{parts.join ', '})"
+        code = "#{block_code}.call(#{parts.join ', '})"
       end
 
       code
@@ -1671,8 +1738,8 @@ module Opal
 
       @redo_var = eval_expr = opts[:scope].temp_local
       code = "#{eval_expr} = false; while (#{eval_expr} || #{truthy}("
-      code += @expr.generate opts, LEVEL_EXPR
-      code += ").$r) {#{eval_expr} = false;"
+      code += generate_truthy_test @expr, opts
+      code += ")) {#{eval_expr} = false;"
 
       opts[:scope].push_while_scope self
 
@@ -1698,6 +1765,43 @@ module Opal
     end
   end
 
+  class ForNode < BaseNode
+
+    def initialize(begn, vars, expr, compstmt, endn)
+      @line = begn[:line]
+      @vars = vars
+      @expr = expr
+      @stmt = compstmt
+      @end_line = endn[:line]
+    end
+
+    def returns
+      @returns = true
+      self
+    end
+
+    def generate(opts, level)
+      @current_scope = opts[:scope]
+      stmt_level = (level == LEVEL_EXPR ? LEVEL_TOP_CLOSURE : LEVEL_TOP)
+
+      if stmt_level == LEVEL_TOP_CLOSURE
+        returns
+        @level_expr = true
+      end
+
+      idx = opts[:scope].temp_local
+      ref = opts[:scope].temp_local
+      len = opts[:scope].temp_local
+      code = "for (#{idx} = 0, #{ref} = #{@expr.generate opts, LEVEL_EXPR}"
+      code += ", #{len} = #{ref}.length; #{idx} < #{len}; #{idx}++) {"
+
+      code += @stmt.process opts, LEVEL_TOP
+
+      code += fix_line_number opts, @end_line
+      code += "}"
+    end
+  end
+
   class SuperNode < BaseNode
 
     def initialize(start, args)
@@ -1781,6 +1885,12 @@ module Opal
         opts[:indent] = old_indent + INDENT
       end
 
+      if opt_ensure = @body.opt_ensure
+        # puts "optional ensure!"
+        code += "} finally {"
+        code += opt_ensure.process opts, LEVEL_TOP
+      end
+
 
       opts[:indent] = old_indent
       code += (fix_line_number(opts, @end_line) + "}")
@@ -1798,7 +1908,8 @@ module Opal
     end
 
     def generate(opts, level)
-      "(#{@expr.generate opts, LEVEL_EXPR}.$r ? #{@true.generate opts, LEVEL_EXPR} : #{@false.generate opts, LEVEL_EXPR})"
+      test = generate_truthy_test @expr, opts
+      "(#{test} ? #{@true.generate opts, LEVEL_EXPR} : #{@false.generate opts, LEVEL_EXPR})"
     end
   end