opal 0.2.2 → 0.3.0

data/lib/opal/gem.rb

@@ -0,0 +1,153 @@
+
+module Opal
+
+  # The gem class wraps around RubyGem's Gem::Specification class to basically add
+  # support for building a gem ready for the browser. The actual gem object can be
+  # accessed through {#spec}.
+  class Gem
+
+    # The real Gem::Specification object, which is used for accessing gem info
+    attr_reader :spec
+
+    # Root directory for the package
+    attr_reader :root_dir
+
+    def initialize(rootdir)
+      require 'rubygems'
+      @root_dir = rootdir
+      path = File.expand_path File.join(@root_dir, File.basename(@root_dir) + '.gemspec')
+
+      # we MUST chdir here to make sure files globs etc in the gemspec use the basedir
+      # as the working directory, otherwise opal, or the main gem working dir will
+      # accidentally be the cwd.
+      Dir.chdir(File.dirname(path)) do
+        @spec = ::Gem::Specification.load path
+      end
+
+      raise "Bad/missing gemspec in #{rootdir}" unless @spec
+    end
+
+    def name
+      @spec.name
+    end
+
+    def version
+      @spec.version.to_s
+    end
+
+    def require_paths
+      @spec.require_paths
+    end
+
+    def files
+      @spec.files
+    end
+
+    def to_s
+      "#<Gem '#{name}'>"
+    end
+
+    # Given the dependency name (required by this package), resolve its
+    # location on disk, or nil if it cannot be found. For now this will only
+    # check the built in locations, but in future it should search within the
+    # package first etc.
+    #
+    # @param {String} dep The name of the dependency
+    # @return {String, nil} Path to package if found
+    def find_dependency(dep)
+      search_dir = File.expand_path File.join(__FILE__, '..', '..', '..', 'gems')
+      # FIXME we should not rely on dirname being same as package name. We should
+      # really go throgh all search dirs in order, and check each directory in that,
+      # and check its json file if it exists, then check the jsons name property
+      package_dir = File.join search_dir, dep
+      return nil unless File.exists? package_dir
+
+      json_file = File.join package_dir, dep + '.gemspec'
+      return nil unless File.exists? json_file
+
+      package_dir
+    end
+
+    # Returns an array of dependencies for this package. Version requirements
+    # are ignored for now. This simply returns the array of package names that
+    # are needed. If the package.json does not declare any, then an empty
+    # array is returned.
+    #
+    # @return {Array<String>}
+    def dependencies
+      dependencies = @spec.dependencies
+
+      dependencies.map { |d| d.name }
+    end
+
+    # Returns the contents of the given file, relative to the root_dir,
+    # wrapped ready for use in the browser. Javascript sources will simply
+    # be wrapped in a function with its free variables, and ruby sources will
+    # be compiled, then wrapped.
+    #
+    # @return {String}
+    def wrap_source(path)
+      full_path = File.expand_path File.join(root_dir, path)
+      ext_name  = File.extname path
+
+      content = case ext_name
+      when '.js'
+        source = File.read full_path
+        "function(VM, self, __FILE__) { #{source} }"
+
+      when '.rb'
+        source = Opal::RubyParser.new(File.read(full_path)).parse!.generate_top
+        # compiled ruby is now javascript, so dont try and fool opal.js!
+        path = path.sub(/\.rb/, '.js')
+        "function(VM, self, __FILE__) { #{source} }"
+
+      else
+        raise "Bad file type for wrapping. Must be ruby or javascript"
+      end
+
+      path.inspect + ": " + content
+    end
+
+    # Returns the files from the .files property of the gem that are only
+    # available from the require_paths array. Basically, these are the files
+    # that are our 'lib' files. They are returned as relative to the root.
+    #
+    # @return [Array<String>]
+    def lib_files
+      paths = require_paths
+      ext = %w[.rb .js] 
+
+      files.select do |f|
+        f.start_with?(*paths) && ext.include?(File.extname(f)) 
+      end
+    end
+
+    # Returns a string that can be written to a file to be used with opal in
+    # the browser.
+    #
+    # @return {String}
+    def to_bundle
+%[
+opal.register("#{self.name}", {
+  "name": #{self.name.inspect},
+  "version": #{self.version.inspect},
+  "require_paths": #{self.require_paths.inspect},
+  "files": {
+    #{lib_files.map { |f| wrap_source f }.join(",\n    ") }
+  }
+});
+]
+    end
+
+    # This will return a simple string. For now, resources etc are not
+    # supported, and will be added back later. This simply calls
+    # to_bundle on itself, and all of its dependencies..
+    #
+    # @return {String}
+    def bundle(opts = {})
+      b = Bundle.new(self, opts)
+      b.build
+    end
+  end
+end
+

data/lib/opal/ruby/nodes.rb

@@ -0,0 +1,1302 @@
+class Opal::RubyParser < Racc::Parser
+
+  # Indent for generated code scopes; 2 spaces, never use tabs
+  INDENT = '  '
+
+  LEVEL_TOP           = 0 # normal top level statements
+  LEVEL_TOP_CLOSURE   = 1 # normal top level, but wrapped in js closure
+  LEVEL_LIST          = 2
+  LEVEL_EXPR          = 3
+
+  # Base node for generators. All other nodes inherit from this
+  class BaseNode
+
+    attr_reader :line
+
+    # Generate the code for this node. This MUST be overriden in subclasses.
+    def generate(opts, level)
+      ''
+    end
+
+    # Makes the node return its value. Overriden by various subclasses. This is
+    # not for use with the ruby return statement, this just means that the
+    # generated scope requires us to return within a javascript function. The
+    # return statement in ruby uses another method for returning.
+    def returns
+      FuncReturnNode.new self
+    end
+
+    # By default, all nodes are expressions (';' to finish them). Statements
+    # override this to be false.
+    def expression?
+      true
+    end
+
+    # Processes the node, which generates it. By default, process will also fix
+    # the line number etc. Some nodes override this as they need a slightly
+    # different approach. This will also set the level for indentation?? To
+    # generate, but not indent or fix the line number, you may call {#generate}
+    # directly. Note that this relies on level. If the level is {LEVEL_LIST},
+    # for example, then a node will not correct its line number or indentation.
+    def process(opts, level)
+      if level <= LEVEL_LIST
+        fix_line_number(opts) + generate(opts, level)
+      else
+        generate opts, level
+      end
+    end
+
+    # Fix line numbers for nodes that need to. This returns code that is used
+    # inside {#process}. Basically, this returns a string of new line chars
+    # which will be prepended to the generated code for this node. This will
+    # use the {@line} local ivar, if present, or you may pass a direct line
+    # number into the {line} parameter.
+    def fix_line_number(opts, line = nil)
+      code = ''
+      # make sure we are on the right line
+      target = line || @line
+      current = opts[:top].line
+
+      if current < target
+        (target - current).times {
+          opts[:top].line += 1
+          code += "\n"
+        }
+
+        code += opts[:indent]
+      end
+
+      code
+    end
+  end
+
+  # Scope nodes. All scope nodes inherit from this node, including: method,
+  # class, def, etc.
+  class ScopeNode < BaseNode
+
+    attr_reader :variables
+
+    attr_reader :parent
+
+    def initialize(parent, statements)
+      @parent = parent
+      @statements = statements
+      # all variables - arg, tempts, params etc
+      @variables = []
+      # all vars for scope and temp
+      @scope_vars = []
+      # temps
+      @temp_current = 'a'
+      @temp_queue = []
+      # ivars..we need to make sure these exist (make sure they are nil if new)
+      @ivars = []
+    end
+
+    def ensure_ivar(name)
+      @ivars << name unless @ivars.include? name
+    end
+
+    def param_variable(name)
+      @variables << name
+    end
+
+    def ensure_variable(name)
+      variable = find_variable name
+      return variable if variable
+
+      # does not exist in scope
+      @scope_vars << name
+      @variables << name
+    end
+
+    def find_variable(name)
+      scope = self
+
+      while scope
+        return name if scope.variables.include? name
+
+        if scope.is_a?(BlockNode) && scope.parent
+          scope = scope.parent
+        else
+          break
+        end
+      end
+
+      nil
+    end
+
+    def temp_local
+      return @temp_queue.pop if @temp_queue.last
+
+      name = '__' + @temp_current
+      @scope_vars << name
+      @temp_current = @temp_current.succ
+      name
+    end
+
+    def queue_temp(temp)
+      @temp_queue << temp
+    end
+
+    def set_uses_block
+      return @block_arg_name if @block_arg_name
+
+      @block_arg_name = '__block__'
+    end
+
+    def generate(opts, level)
+      stmts = @statements.generate opts, level
+      vars = ''
+
+      vars + stmts
+    end
+  end
+
+  # Top level scope. This also manages things like line numbers etc. All opts
+  # will be passed a :top key, that references this root scope (instead of
+  # needing to manually traverse it each time).
+  class TopScopeNode < ScopeNode
+
+    # helpers we need to add to top of file
+    attr_reader :file_helpers
+
+    # keep track of the current line number in the generator
+    attr_accessor :line
+
+    def initialize(statements)
+      super nil, statements
+      @file_helpers = []
+      @line = 1
+      @mm_ids = []
+    end
+
+    # Register a method name that needs to be called to $opal.mm. This method
+    # will remove duplicates.
+    def register_mm_id(mid)
+      @mm_ids << mid unless @mm_ids.include? mid
+    end
+
+    def generate(opts, level)
+      code = []
+      code << super(opts, level)
+
+      pre = ''
+      pre += 'var nil = VM.Qnil, '
+      pre += '$class = VM.dc, $def = VM.dm, $symbol = VM.Y, '
+      pre += '$hash = VM.H, $block = VM.P, Qtrue = VM.Qtrue, Qfalse = VM.Qfalse;'
+
+      # add method missing setup
+      if @mm_ids.length > 0
+        mm_ids = "VM.mm(['#{@mm_ids.join "', '"}']);"
+        pre += mm_ids
+      end
+
+      # local vars... only if we used any..
+      unless @scope_vars.empty?
+        pre = pre + "var #{@scope_vars.join ', '};"
+      end
+
+      # ivars
+      @ivars.each do |ivar|
+        pre += "if (self['#{ivar}'] == undefined) { self['#{ivar}'] = nil; }"
+      end
+
+      pre + code.join('')
+    end
+  end
+
+  # Statements - represents any chain of statements
+  class StatementsNode < BaseNode
+
+    attr_reader :nodes
+
+    def initialize(nodes = [])
+      @line = 0
+      @nodes = nodes
+    end
+
+    def returns
+      if @nodes.length > 0
+        @nodes[-1] = @nodes[-1].returns
+      else
+        @nodes << FuncReturnNode.new(NilNode.new)
+      end
+    end
+
+    def generate(opts, level)
+      code = []
+
+      return NilNode.new.generate(opts, level) if @nodes.empty?
+
+      @nodes.each do |node|
+        node_code = node.process opts, LEVEL_TOP
+
+        if level <= LEVEL_TOP_CLOSURE
+          # to prevent lots of trailing whitespace when we generate statements
+          # on new lines, we only insert indent if we dont have a newline
+          # marker straight away
+          if node_code[0] == "\n"
+            code << node_code
+          else
+            code << (opts[:indent] + node_code)
+          end
+
+          # if expression, add ';' .. statements don't need ';'. We MUST call
+          # this after we generate it, as some statements may determine
+          # themselves during compilation. For example, IfNode does this
+          # depending on whether it needs to generate as a LEVEL_TOP, or as a
+          # LEVEL_TOP_CLOSURE.
+          code << ';' if node.expression?
+
+        else
+          code << node_code
+        end
+      end
+
+      code.join ''
+    end
+
+    # Push more statements onto end.
+    def <<(node)
+      @nodes << node
+      self
+    end
+
+    # Generate statements for top level. Generally used for files
+    def generate_top(opts = {})
+      scope = TopScopeNode.new self
+      opts[:scope] = scope
+      opts[:indent] = ''
+      opts[:top] = scope
+      scope.generate opts, LEVEL_TOP
+    end
+  end
+
+  class NumericNode < BaseNode
+
+    def initialize(val)
+      @line = val[:line]
+      @value = val[:value]
+    end
+
+    def generate(opts, level)
+      @value.to_s
+    end
+  end
+
+  class SymbolNode < BaseNode
+
+    def initialize(val)
+      @line = val[:line]
+      @value = val[:value]
+    end
+
+    def generate(opts, level)
+      "$symbol('#{@value}')"
+    end
+  end
+
+  class CallNode < BaseNode
+
+    # any call may have a block assigned to it
+    attr_writer :block
+
+    attr_reader :recv
+
+    attr_reader :mid
+
+    def initialize(recv, mid, args)
+      @recv = recv
+      @mid = mid[:value]
+      @args = args
+      @line = recv ? recv.line : mid[:line]
+    end
+
+    def mid_to_jsid(id)
+      return ".$m['#{id}']" if /[\!\=\?\+\-\*\/\^\&\%\@\|\[\]\<\>\~]/ =~ id
+
+      # FIXME: if our id is a reserved word in js, we need to also wrap it in
+      # brackets.
+      return ".$m['#{id}']" if js_reserved_words.include? 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]
+    end
+
+    def generate(opts, level)
+      code, arg_res, recv, mid = '', [], nil, nil
+
+      # we need a temp var for the receiver, which we add to the front of
+      # the args to send.
+      tmp_recv = opts[:scope].temp_local
+
+      # receiver
+      if @recv.is_a? NumericNode
+        recv = "(#{@recv.process opts, LEVEL_EXPR})"
+      elsif @recv
+        recv = @recv.process opts, LEVEL_EXPR
+      else
+        recv = SelfNode.new.generate opts, LEVEL_EXPR
+      end
+
+      # method id
+      mid = mid_to_jsid @mid
+
+      # Register our method_id to ensure $opal.mm gets it
+      opts[:top].register_mm_id @mid
+
+      args = @args
+      # normal args
+      if args[0]
+        args[0].each do |arg|
+          arg_res << arg.generate(opts, LEVEL_EXPR)
+        end
+      end
+
+      # hash assoc args
+      if args[2]
+        arg_res << HashNode.new(args[2], { :line => 0 }, { :line => 0 }).generate(opts, LEVEL_EXPR)
+      end
+
+      if @block
+        # tmp_self = opts[:scope].temp_local
+        tmp_args = opts[:scope].temp_local
+        block = @block.generate opts, LEVEL_TOP
+        arg_res.unshift tmp_recv
+
+        code = "(#{tmp_recv} = #{recv}, #{tmp_args} = [#{arg_res.join ', '}]"
+        code += ", ($block.p = #{block}).$self = #{SelfNode.new.generate opts, level}"
+        code += ", ($block.f = #{tmp_recv}#{mid}).apply(#{tmp_recv}, #{tmp_args}))"
+
+        opts[:scope].queue_temp tmp_recv
+        opts[:scope].queue_temp tmp_args
+
+        code
+
+      # &to_proc. Note, this must not reassign the $self for the proc.. we are
+      # just passing on an existing block.
+      #
+      # FIXME need to actually call to_proc.
+      elsif args[3]
+        tmp_args = opts[:scope].temp_local
+
+        arg_res.unshift tmp_recv
+
+        code = "(#{tmp_recv} = #{recv}, #{tmp_args} = [#{arg_res.join ', '}]"
+        code += ", ($block.p = #{args[3].process opts, LEVEL_LIST})"
+        code += ", ($block.f = #{tmp_recv}#{mid}).apply(#{tmp_recv}, #{tmp_args}))"
+
+        opts[:scope].queue_temp tmp_recv
+        opts[:scope].queue_temp tmp_args
+
+        code
+
+      # no block
+      else
+        # splat args
+        if args[1]
+          arg_res.unshift tmp_recv
+          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 = "(#{tmp_recv} = #{recv})" + mid + ".apply(nil, #{splat_args})"
+
+          opts[:scope].queue_temp tmp_recv
+          result
+        else
+          arg_res.unshift tmp_recv
+
+          result = "(#{tmp_recv} = #{recv})" + mid + '(' + arg_res.join(', ') + ')'
+
+          # requeue the tmp receiver as we are done with it and return
+          opts[:scope].queue_temp tmp_recv
+          result
+        end
+      end
+    end
+  end
+
+  class SelfNode < BaseNode
+    # We often use a fake SelfNode for filling in gaps, so it takes a default
+    # hash to save us manually making one every time.
+    def initialize(val = { :line => 0 })
+      @line = val[:line]
+    end
+
+    def generate(opts, level)
+      'self'
+    end
+  end
+
+  class NilNode < BaseNode
+    # Default val hash to save us passing them into fake nodes
+    def initialize(val = { :line => 0 })
+      @line = val[:line]
+    end
+
+    def generate(opts, level)
+      'nil'
+    end
+  end
+
+  class ModuleNode < ScopeNode
+
+    def initialize(mod, path, body, _end)
+      super nil, body
+      @line = mod[:line]
+      @base = path[0]
+      @class_name = path[1][:value]
+      @end_line = _end[:line]
+    end
+
+    def generate(opts, level)
+      code = '$class('
+
+      # base
+      if @base.nil?
+        code += SelfNode.new.generate(opts, level)
+      else
+        code += 'w'
+      end
+
+      code += ', '
+
+      # superclass
+      code += (NilNode.new.generate(opts, level) + ', ')
+
+      # module name
+      code += "'#{@class_name}', "
+
+      # scope
+      scope = { :indent => opts[:indent] + INDENT, :top => opts[:top], :scope => self }
+      stmt = @statements.generate scope, LEVEL_TOP
+
+      code += ('function() { var self = this; ' + stmt)
+
+      # fix line ending
+      code += fix_line_number opts, @end_line
+      code += '}, 2)'
+
+      code
+    end
+  end
+
+  class ClassNode < ScopeNode
+
+    def initialize(cls, path, sup, body, _end)
+      super nil, body
+      @scope_vars << 'self = this'
+      @line = cls[:line]
+      @base = path[0]
+      @cls_name = path[1]
+      @super = sup
+      @end_line = _end[:line]
+    end
+
+    def generate(opts, level)
+      code = '$class('
+
+      # base
+      code += (@base.nil? ? SelfNode.new.generate(opts, level) : 'w')
+      code += ', '
+
+      # superclass
+      code += (@super ? @super.generate(opts, level) : NilNode.new.generate(opts, level))
+      code += ', '
+
+      # class name
+      code += "'#{@cls_name[:value]}', "
+
+      # scope
+      scope = { :indent => opts[:indent] + INDENT, :top => opts[:top], :scope => self }
+      stmt = @statements.generate scope, level
+      code += "function() { var #{@scope_vars.join ', '};#{stmt}"
+
+      # fix trailing line number
+      code += fix_line_number opts, @end_line
+
+      code += opts[:indent] + '}, 0)'
+      code
+    end
+  end
+
+  class DefNode < ScopeNode
+
+    def initialize(defn, singleton, fname, args, body, endn)
+      super nil, body
+      # do this early
+      @line = defn[:line]
+      @singleton = singleton
+      @fname = fname
+      @args = args
+      @body = body
+      @end_line = endn[:line]
+    end
+
+    def generate(opts, level)
+      code = '$def('
+
+      # singleton
+      code += (@singleton ? @singleton.generate(opts, level) : SelfNode.new.generate(opts, level))
+      code += ', '
+
+      # method id
+      code += "'#{@fname[:value]}', "
+
+      # all method arg names need to be places in function arg list
+      method_args = []
+
+      pre_code = ''
+
+      # scope
+      scope = { :indent => opts[:indent] + INDENT, :top => opts[:top], :scope => self }
+
+      args = @args
+
+      # normal args
+      if args[0]
+        args[0].each do |arg|
+          param_variable arg[:value]
+          method_args << arg[:value]
+        end
+      end
+
+      # optional args
+      if args[1]
+        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)};}"
+        end
+      end
+
+      # rest args
+      if args[2]
+        param_variable args[2][:value]
+        method_args << args[2][:value]
+        pre_code += "#{args[2][:value]} = [].slice.call(arguments, #{method_args.length});"
+      end
+
+      # block arg
+      if args[3]
+        param_variable args[3][:value]
+        @block_arg_name = args[3][:value]
+      end
+
+      @body.returns
+      stmt = @body.generate scope, LEVEL_TOP
+
+      method_args.unshift 'self'
+
+      code += "function(#{method_args.join ', '}) { "
+
+      # local vars... only if we used any..
+      unless @scope_vars.empty?
+        pre_code = "var #{@scope_vars.join ', '};" + pre_code
+      end
+
+      # ivars
+      @ivars.each do |ivar|
+        pre_code += "if (self['#{ivar}'] == undefined) { self['#{ivar}'] = nil; }"
+      end
+
+      # block arg
+      if @block_arg_name
+        pre_code += " var #{@block_arg_name} = ($block.f == arguments.callee)"
+        pre_code += " ? $block.p : nil; $block.p = $block.f = nil;"
+      end
+
+      code += (pre_code + stmt)
+
+      # fix trailing end and 0/1 for normal/singleton
+      code += (fix_line_number(opts, @end_line) + "}, #{@singleton ? '1' : '0'})")
+
+      code
+    end
+  end
+
+  class BodyStatementsNode < BaseNode
+
+    attr_reader :opt_rescue
+
+    def initialize(stmt, optrescue, optelse, optensure)
+      @statements = stmt
+      @opt_rescue = optrescue
+      @opt_else = optelse
+      @opt_ensure = optensure
+      @line = stmt.line
+    end
+
+    def returns
+      @statements.returns
+    end
+
+    def generate(opts, level)
+      @statements.generate opts, level
+    end
+  end
+
+  class OrNode < BaseNode
+
+    def initialize(node, lhs, rhs)
+      @line = node[:line]
+      @lhs = lhs
+      @rhs = rhs
+    end
+
+    def generate(opts, level)
+      res = '(('
+      tmp = opts[:scope].temp_local
+      res += "#{tmp} = #{@lhs.generate opts, LEVEL_LIST}).$r ? "
+      res += "#{tmp} : #{@rhs.generate opts, LEVEL_LIST})"
+      opts[:scope].queue_temp tmp
+      res
+    end
+  end
+
+  class AndNode < BaseNode
+
+    def initialize(node, lhs, rhs)
+      @line = node[:line]
+      @lhs = lhs
+      @rhs = rhs
+    end
+
+    def generate(opts, level)
+      res = '(('
+      tmp = opts[:scope].temp_local
+      res += "#{tmp} = #{@lhs.generate opts, LEVEL_LIST}).$r ? "
+      res += "#{@rhs.generate opts, LEVEL_LIST} : #{tmp})"
+      opts[:scope].queue_temp tmp
+      res
+    end
+  end
+
+  class ArrayNode < BaseNode
+
+    def initialize(parts, begn, endn)
+      @line = begn[:line]
+      @end_line = endn[:line]
+      @args = parts
+    end
+
+    # We should really alter opts[:indent] to temp increase it so that args
+    # on a new line are indented to that of the array beg/end
+    def generate(opts, level)
+      parts = @args[0].map { |arg| arg.process opts, LEVEL_LIST }
+      "[#{parts.join ', '}#{fix_line_number opts, @end_line}]"
+    end
+  end
+
+  class HashNode < BaseNode
+
+    def initialize(parts, begn, endn)
+      @line = begn[:line]
+      @end_line = endn[:line]
+      @parts = parts
+    end
+
+    def generate(opts, level)
+      parts = @parts.flatten.map { |part| part.process opts, LEVEL_LIST }
+      "$hash(#{parts.join ', '}#{fix_line_number opts, @end_line})"
+    end
+  end
+
+  class IfNode < BaseNode
+
+    def initialize(begn, expr, stmt, tail, endn)
+      @line = begn[:line]
+      @end_line = endn[:line]
+      @expr = expr
+      @stmt = stmt
+      @tail = tail
+    end
+
+    def returns
+      @stmt.returns
+      # need to apply to each tail item
+      @tail.each do |tail|
+        if tail[0][:value] == 'elsif'
+          tail[2].returns
+        else
+          tail[1].returns
+        end
+      end
+      self
+    end
+
+    def expression?
+      @expr_level
+    end
+
+    def generate(opts, level)
+      code, done_else, tail, old_indent = '', false, nil, opts[:indent]
+
+      opts[:indent] += INDENT
+
+      # stmt_level is level_top, unless we are an expression.. then it is level_top_closure..
+      stmt_level = (level == LEVEL_EXPR ? LEVEL_TOP_CLOSURE : LEVEL_TOP)
+
+      if stmt_level == LEVEL_TOP_CLOSURE
+        returns
+        @level_expr = true
+      end
+
+      code += "if ((#{@expr.generate opts, LEVEL_EXPR}).$r) {#{@stmt.process opts, stmt_level}"
+
+      @tail.each do |tail|
+        opts[:indent] = old_indent
+        code += fix_line_number opts, tail[0][:line]
+
+        if tail[0][:value] == 'elsif'
+          code += "} else if ((#{tail[1].generate opts, LEVEL_EXPR}).$r) {"
+          opts[:indent] += INDENT
+          code += tail[2].process(opts, stmt_level)
+        else
+          done_else = true
+          code += '} else {'
+          opts[:indent] += INDENT
+          code += tail[1].process(opts, stmt_level)
+        end
+      end
+
+      if @force_else
+        # generate an else statement if we MUST have one. If, for example, we
+        # set the result of ourself as a variable, we must have an else part
+        # which simply returns nil.
+      end
+
+      opts[:indent] = old_indent
+      code += (fix_line_number(opts, @end_line) + '}')
+
+      # if we were an expression, we need to wrap ourself as closure
+      code = "(function() {#{code})()" if level == LEVEL_EXPR
+      code
+    end
+  end
+
+  class ConstantNode < BaseNode
+
+    def initialize(name)
+      @line = name[:line]
+      @name = name[:value]
+    end
+
+    def value
+      @name
+    end
+
+    def generate(opts, level)
+      "rb_vm_cg(#{SelfNode.new.generate opts, level}, '#{@name}')"
+    end
+  end
+
+  class Colon2Node < BaseNode
+
+    def initialize(lhs, name)
+      @lhs = lhs
+      @line = name[:line]
+      @name = name[:value]
+    end
+
+    def generate(opts, level)
+      # FIXME This should really be 'const at'.. const_get will relook all the way up chain
+      "rb_vm_cg(#{@lhs.generate opts, level}, '#{@name}')"
+    end
+  end
+
+  class Colon3Node < BaseNode
+
+    def initialize(name)
+      @line = name[:line]
+      @name = name[:value]
+    end
+
+    def generate(opts, level)
+      "rm_vm_cg($opal.Object, '#{@name}')"
+    end
+  end
+
+  class AssignNode < BaseNode
+
+    def initialize(lhs, rhs, assign = {})
+      @line = lhs.line
+      @lhs = lhs
+      @rhs = rhs
+    end
+
+    def generate(opts, level)
+      if @lhs.is_a? IvarNode
+        return "#{SelfNode.new.generate(opts, level)}['#{@lhs.value}'] = #{@rhs.generate(opts, LEVEL_EXPR)}"
+
+      elsif @lhs.is_a? GvarNode
+        return "VM.gs('#{@lhs.value}', #{@rhs.generate(opts, LEVEL_EXPR)})"
+
+      elsif @lhs.is_a? IdentifierNode
+        opts[:scope].ensure_variable @lhs.value
+        return @lhs.value + " = " + @rhs.generate(opts, LEVEL_EXPR)
+
+      elsif @lhs.is_a? ArefNode
+        return AsetNode.new(@lhs.recv, @lhs.arefs, @rhs).process(opts, level)
+
+      elsif @lhs.is_a? ConstantNode
+        return "rb_vm_cs(self, '#{@lhs.value}', #{@rhs.generate(opts, LEVEL_EXPR)})"
+
+      elsif @lhs.is_a? CallNode
+        return CallNode.new(@lhs.recv, { :value => @lhs.mid + '=', :line => @line }, [[@rhs]]).generate(opts, level);
+
+      else
+        raise "Bad lhs for assign on #{@line}"
+      end
+    end
+  end
+
+  class OpAsgnNode < BaseNode
+
+    def initialize(asgn, lhs, rhs)
+      @line = asgn[:line]
+      @lhs  = lhs
+      @rhs  = rhs
+      @asgn = asgn[:value]
+    end
+
+    def generate(opts, level)
+      assign = nil
+
+      if @asgn == '||'
+        assign = OrNode.new({:value => '||', :line => @line }, @lhs, AssignNode.new(@lhs, @rhs))
+      elsif %w[+ - / *].include? @asgn
+        assign = AssignNode.new @lhs, CallNode.new(@lhs, {:value => @asgn, :line => @line}, [[@rhs]])
+      else
+        raise "Bas op asgn type: #{@asgn}"
+      end
+      assign.generate(opts, level)
+    end
+  end
+
+  class IvarNode < BaseNode
+
+    attr_reader :value
+
+    def initialize(val)
+      @line = val[:line]
+      @value = val[:value]
+    end
+
+    def generate(opts, level)
+      opts[:scope].ensure_ivar @value
+      "#{SelfNode.new.generate(opts, level)}['#{@value}']"
+    end
+  end
+
+  class IdentifierNode < BaseNode
+
+    attr_reader :value
+
+    def initialize(val)
+      @line = val[:line]
+      @value = val[:value]
+    end
+
+    def generate(opts, level)
+      if opts[:scope].find_variable @value
+        @value
+      else
+        CallNode.new(nil, { :value => @value, :line => @line }, [[]]).generate(opts, level)
+      end
+    end
+  end
+
+  class FuncReturnNode < BaseNode
+
+    def initialize(val)
+      @value = val
+      @line = val.line
+    end
+
+    def generate(opts, level)
+      "return #{@value.generate opts, level}"
+    end
+  end
+
+  class StringNode < BaseNode
+
+    def initialize(parts, endn)
+      @line = endn[:line]
+      @parts = parts
+      @join = endn[:value]
+    end
+
+    def generate(opts, level)
+      if @parts.length == 0
+        "''"
+      elsif @parts.length == 1
+        if @parts[0][0] == 'string_content'
+          @join + @parts[0][1][:value] + @join
+        end
+
+      else
+        parts = @parts.map do |part|
+          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)
+          end
+        end
+
+        '(' + parts.join(' + ') + ')'
+      end
+    end
+  end
+
+  class TrueNode < BaseNode
+
+    def initialize(val)
+      @line = val[:line]
+    end
+
+    def generate(opts, level)
+      "Qtrue"
+    end
+  end
+
+  class FalseNode < BaseNode
+
+    def initialize(val)
+      @line = val[:line]
+    end
+
+    def generate(opts, level)
+      "Qfalse"
+    end
+  end
+
+  class BlockNode < ScopeNode
+
+    def initialize(start, vars, stmt, endn)
+      super nil, stmt
+      @line = start[:line]
+      @args = vars
+      @stmt = stmt
+      @end_line = endn[:line]
+    end
+
+    def generate(opts, level)
+      @parent   = opts[:scope]
+      pre_code  = ''
+      code      = ''
+
+      scope = { :scope => self, :top => opts[:top], :indent => opts[:indent] + INDENT }
+      args = @args[0]
+      method_args = []
+
+      if args
+        # normal args
+        if args[0]
+          args[0].each do |arg|
+            param_variable arg[:value]
+            method_args << arg[:value]
+          end
+        end
+
+        # optional args
+        if args[1]
+          args[1].each do |arg|
+            opt_arg_name = arg[0][:value]
+            param_variable opt_arg_name
+            method_args << arg[0][:value]
+            pre_code += "if (#{opt_arg_name} == undefined) { #{opt_arg_name} = #{arg[1].generate(opts, level)};}"
+          end
+        end
+
+        # rest args
+        if args[2]
+          rest_arg_name = args[2][:value]
+          # 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(arguments, #{method_args.length});"
+        end
+      end
+
+      @stmt.returns
+      stmt = @stmt.process scope, LEVEL_TOP
+      method_args.unshift 'self'
+
+      code += "function(#{method_args.join ', '}) {"
+      
+      unless @scope_vars.empty?
+        code += " var #{@scope_vars.join ', '};"
+      end
+
+      code += (pre_code + stmt + fix_line_number(opts, @end_line) + "}")
+      code
+    end
+  end
+
+  class XStringNode < BaseNode
+
+    def initialize(begn, parts, endn)
+      @line = begn[:line]
+      @parts = parts
+      @end_line = endn[:line]
+    end
+
+    # we dont want return for xstring.. or do we? no..
+    def returns
+      self
+    end
+
+    # Treat ourself like an expression. All xstrings should add their own
+    # semi-colons etc, so we can allow if, return, etc.
+    def expression?
+      false
+    end
+
+    def generate(opts, level)
+      parts = @parts.map do |part|
+        if part[0] == 'string_content'
+          part[1][:value]
+        elsif part[0] == 'string_dbegin'
+          part[1].generate opts, LEVEL_EXPR
+        end
+      end
+
+      parts.join ''
+    end
+  end
+
+  class ParenNode < BaseNode
+
+    def initialize(opening, parts, closing)
+      @line = opening[:line]
+      @parts = parts
+      @end_line = closing[:line]
+    end
+
+    def generate(opts, level)
+      parts = @parts.nodes.map do |part|
+        part.generate opts, LEVEL_EXPR
+      end
+
+      # if no parens, then we need to eval to nil
+      parts << 'nil' if parts.empty?
+
+      "(#{parts.join ', '})"
+    end
+  end
+
+  class ArefNode < BaseNode
+
+    attr_reader :recv
+
+    attr_reader :arefs
+
+    def initialize(recv, arefs)
+      @line = recv.line
+      @recv = recv
+      @arefs = arefs
+    end
+
+    def generate(opts, level)
+      CallNode.new(@recv, { :line => @line, :value => '[]'}, @arefs).generate opts, level
+    end
+  end
+
+  class AsetNode < BaseNode
+
+    def initialize(recv, arefs, val)
+      @line = recv.line
+      @recv = recv
+      @arefs = arefs
+      @val = val
+    end
+
+    def generate(opts, level)
+      (@arefs[0] ||= []) << @val
+      CallNode.new(@recv, { :line => @line, :value => '[]='}, @arefs ).generate(opts, level)
+    end
+  end
+
+  # Used for post form of IF and UNLESS statements
+  class IfModNode < BaseNode
+
+    def initialize(type, expr, stmt)
+      @line = type[:line]
+      @type = type[:value]
+      @expr = expr
+      @stmt = stmt
+    end
+
+    # If we return, that means our "else" result - which is not generated by
+    # default, needs to return nil (as it might be needed if our if statement
+    # does not evaluate truthy
+    def returns
+      @returns = true
+      @stmt = @stmt.returns
+      self
+    end
+
+    def generate(opts, level)
+      # 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)}}"
+
+      # also, if we return, we need to ensure we have an else conditional
+      r += " else { return nil; }" if @returns
+      r
+    end
+  end
+
+  class BlockGivenNode < BaseNode
+
+    def initialize(given)
+      @line = given[:line]
+    end
+
+    def generate(opts, level)
+      name = opts[:scope].set_uses_block
+      "(#{name} !== nil ? Qtrue : Qfalse)"
+    end
+  end
+
+  class YieldNode < BaseNode
+
+    def initialize(start, args)
+      @line = start[:line]
+      @args = args
+    end
+
+    def generate(opts, level)
+      # need to get block from nearest method
+      block = opts[:scope].set_uses_block
+
+      parts = ["#{block}.$self"]
+
+      if @args[0]
+        @args[0].each { |arg| parts << arg.generate(opts, LEVEL_EXPR) }
+      end
+
+      "#{block}(#{parts.join ', '})"
+    end
+  end
+
+  class ReturnNode < BaseNode
+
+    def initialize(ret, val)
+      @line = ret[:line]
+      @args = val
+    end
+
+    def returns
+      self
+    end
+
+    def generate(opts, level)
+      args = @args
+
+      if args[0].nil?
+        code = NilNode.new.generate opts, level
+      elsif args[0].length == 1
+        code = args[0][0].generate opts, level
+      else
+        # this really should return array of return vals
+        code = NilNode.new.generate opts, level
+      end
+
+      # if we are in a block, we need to throw return to nearest mthod
+      if !opts[:scope].is_a?(DefNode)
+        return_func = '__return_func'
+        return "$return(#{code}, #{return_func})"
+
+      # level top, we are running full stmts, so just return normally
+      elsif level == LEVEL_TOP
+        return "return #{code}"
+      else
+        "$return(#{code})"
+      end
+    end
+  end
+
+  class BeginNode < BaseNode
+
+    def initialize(beginn, body, endn)
+      @line = beginn[:line]
+      @body = body
+      @end_line = endn[:line]
+    end
+
+    def generate(opts, level)
+      code = "try {"
+      old_indent = opts[:indent]
+      opts[:indent] += INDENT
+
+      code += @body.process opts, LEVEL_TOP
+      code += "} catch (__err__) {"
+
+      @body.opt_rescue.each do |res|
+        code += "#{fix_line_number opts, res[0][:line]}if (true){"
+        opts[:indent] += INDENT
+        opts[:scope].ensure_variable res[2].value
+        code += (res[2].value + " = __err__;")
+        code += "#{res[3].process opts, LEVEL_TOP}}"
+        opts[:indent] = old_indent + INDENT
+      end
+
+
+      opts[:indent] = old_indent
+      code += (fix_line_number(opts, @end_line) + "}")
+      code
+    end
+  end
+
+  class GvarNode < BaseNode
+
+    attr_reader :value
+
+    def initialize(val)
+      @line = val[:line]
+      @value = val[:value]
+    end
+
+    def generate(opts, level)
+      "VM.gg('#{@value}')"
+    end
+  end
+
+  class FileNode < BaseNode
+
+    def initialize(val)
+      @line = val[:line]
+    end
+
+    def generate(opts, level)
+      "__FILE__"
+    end
+  end
+
+  class LineNode < BaseNode
+
+    def initialize(val)
+      @line = val[:line]
+      @val = val[:value]
+    end
+
+    def generate(opts, level)
+      @val
+    end
+  end
+end
+