opal 0.3.10 → 0.3.11

data/lib/opal/context.rb

@@ -1,38 +1,15 @@
 module Opal
   class Context
-
-    def initialize(root_dir = Dir.getwd)
-      @root_dir = root_dir
-      @builder = Opal::Builder.new
+    # Options are mainly just passed onto the builder/parser.
+    def initialize(options = {})
+      @options      = options
+      @root_dir     = options[:dir] || Dir.getwd
+      @builder      = Opal::Builder.new
       @loaded_paths = false
 
-      # special case: if we are running in opal root, then we dont want
-      # setup.rb to load the opal lib itself, so we do some "magic"
-      if @root_dir == OPAL_DIR
-        def self.setup_load_paths
-          return if @loaded_paths
-          Dir['packages/*/package.yml'].map do |package|
-            path = File.expand_path File.join(File.dirname(package), 'lib')
-            @v8.eval "opal.loader.paths.push('#{path}')"
-          end
-        end
-      end
-
       setup_v8
     end
 
-    ##
-    # Looks through vendor/ directory and adds all relevant load paths
-
-    def setup_load_paths
-      return if @loaded_paths
-
-      setup = File.join @root_dir, 'packages', 'init.rb'
-      return [] unless File.exists? setup
-
-      @v8.eval "opal.run(function() {opal.require('#{setup}');});", setup
-    end
-
     ##
     # Require the given id as if it was required in the context. This simply
     # passes the require through to the underlying context.
@@ -43,17 +20,14 @@ module Opal
       finish
     end
 
-    ##
-    # Set ARGV for the context
-
+    # Set ARGV for the context.
+    # @param [Array<String>] args
     def argv=(args)
       puts "setting argv to #{args.inspect}"
       @v8.eval "opal.runtime.cs(opal.runtime.Object, 'ARGV', #{args.inspect});"
     end
 
-    ##
     # Start normal js repl
-
     def start_repl
       require 'readline'
       setup_v8
@@ -74,26 +48,20 @@ module Opal
       finish
     end
 
-    def eval(content, file = nil, line = "")
-      begin
-        js = @builder.parse content
-        code = "opal.run(function() { var $rb = opal.runtime, self = $rb.top"
-        code += ", __FILE__ = '(opal)'; return (#{js})($rb, self, __FILE__); })"
-        # puts code
-        @v8['$opal_irb_result'] = @v8.eval(code, file)
-        @v8.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
+    def eval(content, file = "(opal)", line = "")
+      js = @builder.parse content, @options
+      code =  "opal.run(function() { var result = (#{js})(opal.runtime, "
+      code += "opal.runtime.top, '(opal)'); if (result == null || !result"
+      code += ".m$inspect) { return '(Object does not support #inspect)'; }"
+      code += "else { return result.m$inspect() } });"
+
+      @v8.eval code, file
     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
       @v8.eval "opal.runtime.do_at_exit()", "(opal)"
@@ -116,14 +84,12 @@ module Opal
       @v8 = V8::Context.new
       @v8['console'] = Console.new
 
-      @v8.eval @builder.build_core, '(opal)'
+      @v8.eval File.read(OPAL_JS_PATH), "(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, @v8.eval("[]")
-
-      setup_load_paths
     end
 
     ##

data/lib/opal/lexer.rb

@@ -12,7 +12,7 @@ module Opal
   #   parser = Opal::Parser.new
   #
   #   parser.parse "self.do_something 1, 2, 3"
-  #   # => "some ruby content"
+  #   # => "compiled javascript"
   class Parser < Racc::Parser
 
     # Thrown on parsing error
@@ -34,6 +34,25 @@ module Opal
     #       in future bindings. `false` means its just a normal scope,
     #       i.e. top. This is only needed in [Context] for irb.
     #
+    #   `:overload_arithmetic` - whether to overload arithmetic operators
+    #       or not. This defaults to `false` so that all method calls for
+    #       `+`, `-`, `*`, `/`, `%`, `-@`, `-@` are just compiled directly
+    #       into their javascript ops. Set to `true` to use ruby style
+    #       operator overloading.
+    #
+    #   `:overload_bitwise` - whether to overload bitwise operators. This
+    #       applies to `&`, `|`, `^` and `~`. Defaults to `false`.
+    #
+    #   `:overload_shift` - whether to overload shift bitwise operators.
+    #       This applies to `<<` and `>>`. `<<` is generally useful for
+    #       arrays so we keep it seperate. Defaults to `true`.
+    #
+    #   `:overload_equal` - whether to overload `==` and `!==` operators.
+    #       This defaults to `false`.
+    #
+    #   `:overload_comparison` - whether to overload `<`, `<=`, `>` and
+    #       `>=` operators. Defaults to `false`.
+    #
     # @param [String] source ruby source code to parse
     # @param [Hash] options parsing options to use
     def parse(source, options = {})
@@ -45,7 +64,7 @@ module Opal
       @scanner            = StringScanner.new source
       nodes               = do_parse
 
-      return nodes.generate_top
+      return nodes.generate_top(options)
     end
 
     def next_token

data/lib/opal/nodes.rb

@@ -80,7 +80,7 @@ module Opal
     end
 
     def generate_truthy_test(expr, opts)
-      if expr.is_a? ComparisonNode
+      if expr.is_a?(EqualNode) || expr.is_a?(ComparisonNode)
         expr.generate opts, LEVEL_EXPR
       else
         tmp = opts[:scope].temp_local
@@ -218,6 +218,28 @@ module Opal
       @line = 1
     end
 
+    # [Parser] options
+    def options=(opts)
+      @overload_arithmetic = opts[:overload_arithmetic] || false
+      @overload_comparison = opts[:overload_comparison] || false
+      @overload_bitwise    = opts[:overload_bitwise] || false
+      @overload_shift      = opts[:overload_shift] || true
+      @overload_equal      = opts[:overload_equal] || false
+      @method_missing      = opts[:method_missing] || false
+    end
+
+    def overload_arithmetic?; @overload_arithmetic; end
+
+    def overload_comparison?; @overload_comparison; end
+
+    def overload_bitwise?; @overload_bitwise; end
+
+    def overload_shift?; @overload_shift; end
+
+    def overload_equal?; @overload_equal; end
+
+    def method_missing?; @method_missing; end
+
     def generate(opts, level)
       @opts = opts
       code = []
@@ -235,7 +257,7 @@ module Opal
 
       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 += '$range = $rb.G, $hash = $rb.H, $B = $rb.P, $rb_send = $rb.sm'
 
       post += ';'
 
@@ -315,12 +337,17 @@ module Opal
     end
 
     # Generate statements for top level. Generally used for files
-    def generate_top(opts = {})
+    def generate_top(parser_options = {})
       scope = TopScopeNode.new self
-      opts[:scope] = scope
-      opts[:indent] = ''
-      opts[:top] = scope
-      scope.generate opts, LEVEL_TOP
+      opts  = {}
+
+      scope.options = parser_options
+
+      opts[:scope]   = scope
+      opts[:indent]  = ''
+      opts[:top]     = scope
+
+      return scope.generate opts, LEVEL_TOP
     end
   end
 
@@ -398,9 +425,16 @@ module Opal
         recv = "self"
       end
 
-      mid = mid_to_jsid(mid)
+      # dispatch is true if we use the dispatch method (i.e. we want
+      # to support method missing).
+      dispatch = opts[:top].method_missing?
+
+      unless dispatch
+        mid = mid_to_jsid mid
+      end
 
       args = @args
+
       # normal args
       if args[0]
         args[0].each do |arg|
@@ -443,19 +477,34 @@ module Opal
       else
         # splat args
         if args[1]
-          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 = "(#{tmp_recv} = #{recv})" + mid + ".apply(#{tmp_recv}, #{splat_args})"
 
+          if dispatch
+            arg_res.unshift recv, "'#{mid}'"
+            splat_args = "[#{arg_res.join ', '}].concat(#{splat})"
+
+            return "$rb_send.apply(null, #{splat_args})"
+          end
+
+          # non-disptach
+          tmp_recv = opts[:scope].temp_local
+          splat_args = arg_res.empty? ? "#{splat}" :
+                       "[#{arg_res.join ', '}].concat(#{splat})"
+
+          result =  "(#{tmp_recv} = #{recv})" + mid + ".apply("
+          result += "#{tmp_recv}, #{splat_args})"
           opts[:scope].queue_temp tmp_recv
-          result
+
+          return result
+
+        # not a block call, and not a &to_proc call
         else
-          result = "#{recv}#{mid}(#{arg_res.join(', ')})"
-          result
+          if dispatch
+            arg_res.unshift recv, "'#{mid}'"
+            "$rb_send(#{arg_res.join ', '})"
+          else
+            "#{recv}#{mid}(#{arg_res.join(', ')})"
+          end
         end
       end
     end
@@ -1265,6 +1314,59 @@ module Opal
     end
   end
 
+  class ArithmeticNode < BaseNode
+    def initialize(lhs, op, rhs)
+      @lhs  = lhs
+      @op   = op[:value]
+      @line = op[:line]
+      @rhs  = rhs
+    end
+
+    def generate(opts, level)
+      lhs = @lhs.generate opts, LEVEL_EXPR
+      rhs = @rhs.generate opts, LEVEL_EXPR
+
+      if opts[:top].overload_arithmetic?
+        if opts[:top].method_missing?
+          return "$rb_send(#{lhs}, 'm$#{@op}', #{rhs})"
+        else
+          lhs = "(#{lhs})" if @lhs.is_a? NumericNode
+          return "#{lhs}['m$#{@op}'](#{rhs})"
+        end
+      else
+        return "#{lhs} #{@op} #{rhs}"
+      end
+    end
+  end
+
+  class EqualNode < BaseNode
+    def initialize(lhs, op, rhs)
+      @line = op[:line]
+      @op   = op[:value]
+      @lhs  = lhs
+      @rhs  = rhs
+    end
+
+    def generate(opts, level)
+      lhs = @lhs.generate opts, LEVEL_EXPR
+      rhs = @rhs.generate opts, LEVEL_EXPR
+
+      if opts[:top].overload_equal?
+        if opts[:top].method_missing?
+          return "$rb_send(#{lhs}, 'm$#{@op}', #{rhs})"
+        else
+          lhs = "(#{lhs})" if @lhs.is_a? NumericNode
+          return "#{lhs}['m$#{@op}'](#{rhs})"
+        end
+      else
+        op  = "#{@op}="
+        lhs = "(#{lhs})" if @lhs.is_a? NumericNode
+        rhs = "(#{rhs})" if @rhs.is_a? NumericNode
+        return "#{lhs}.valueOf() #{op} #{rhs}.valueOf()"
+      end
+    end
+  end
+
   class ComparisonNode < BaseNode
 
     def initialize(op, lhs, rhs)
@@ -1279,10 +1381,22 @@ module Opal
       lhs = "(#{lhs})" if @lhs.is_a? NumericNode
       rhs = @rhs.generate opts, LEVEL_EXPR
 
-      if @op == '!='
-        "!#{lhs}['m$=='](#{rhs})"
+      if opts[:top].overload_equal?
+        if @op == '!='
+          "!#{lhs}['m$=='](#{rhs})"
+        else
+          "#{lhs}['m$#{@op}'](#{rhs})"
+        end
       else
-        "#{lhs}['m$#{@op}'](#{rhs})"
+        if @op == '!='
+          rhs = "(#{rhs})" if @rhs.is_a? NumericNode
+          "#{lhs}.valueOf() !== #{rhs}.valueOf()"
+        elsif @op == '=='
+          rhs = "(#{rhs})" if @rhs.is_a? NumericNode
+          "#{lhs}.valueOf() === #{rhs}.valueOf()"
+        else
+          "#{lhs} #{@op} #{rhs}"
+        end
       end
     end
   end

data/lib/opal/parser.rb

@@ -3451,31 +3451,31 @@ def _reduce_178(val, _values, result)
 end
 
 def _reduce_179(val, _values, result)
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ArithmeticNode.new val[0], val[1], val[2]
     
     result
 end
 
 def _reduce_180(val, _values, result)
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ArithmeticNode.new val[0], val[1], val[2]
     
     result
 end
 
 def _reduce_181(val, _values, result)
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ArithmeticNode.new val[0], val[1], val[2]
     
     result
 end
 
 def _reduce_182(val, _values, result)
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ArithmeticNode.new val[0], val[1], val[2]
     
     result
 end
 
 def _reduce_183(val, _values, result)
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ArithmeticNode.new val[0], val[1], val[2]
     
     result
 end
@@ -3547,7 +3547,7 @@ def _reduce_194(val, _values, result)
 end
 
 def _reduce_195(val, _values, result)
-      result = ComparisonNode.new val[1], val[0], val[2]
+      result = EqualNode.new val[0], val[1], val[2]
     
     result
 end
@@ -3559,7 +3559,7 @@ def _reduce_196(val, _values, result)
 end
 
 def _reduce_197(val, _values, result)
-      result = ComparisonNode.new val[1], val[0], val[2]
+      result = EqualNode.new val[0], val[1], val[2]
     
     result
 end

data/lib/opal/parser.y

@@ -377,23 +377,23 @@ arg:
     }
   | arg '+' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ArithmeticNode.new val[0], val[1], val[2]
     }
   | arg '-' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ArithmeticNode.new val[0], val[1], val[2]
     }
   | arg '*' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ArithmeticNode.new val[0], val[1], val[2]
     }
   | arg '/' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ArithmeticNode.new val[0], val[1], val[2]
     }
   | arg '%' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ArithmeticNode.new val[0], val[1], val[2]
     }
   | arg '**' arg
     {
@@ -441,7 +441,7 @@ arg:
     }
   | arg '==' arg
     {
-      result = ComparisonNode.new val[1], val[0], val[2]
+      result = EqualNode.new val[0], val[1], val[2]
     }
   | arg '===' arg
     {
@@ -449,7 +449,7 @@ arg:
     }
   | arg '!=' arg
     {
-      result = ComparisonNode.new val[1], val[0], val[2]
+      result = EqualNode.new val[0], val[1], val[2]
     }
   | arg '=~' arg
     {