opal 0.8.1 → 0.9.0.beta1

data/lib/opal/compiler.rb

@@ -84,6 +84,18 @@ module Opal
     # @return [Boolean]
     compiler_option :arity_check, false, :as => :arity_check?
 
+    # @!method freezing?
+    #
+    # stubs out #freeze and #frozen?
+    #
+    # @return [Boolean]
+    compiler_option :freezing, true, :as => :freezing?
+
+    # @!method tainting?
+    #
+    # stubs out #taint, #untaint and #tainted?
+    compiler_option :tainting, true, :as => :tainting?
+
     # @!method irb?
     #
     # compile top level local vars with support for irb style vars

data/lib/opal/config.rb

@@ -6,6 +6,8 @@ module Opal
       {
         method_missing_enabled:    true,
         arity_check_enabled:       false,
+        freezing_stubs_enabled:    true,
+        tainting_stubs_enabled:    true,
         const_missing_enabled:     true,
         dynamic_require_severity:  :error, # :error, :warning or :ignore
         irb_enabled:               false,
@@ -25,6 +27,8 @@ module Opal
     COMPILER_KEYS = {
       method_missing:           :method_missing_enabled,
       arity_check:              :arity_check_enabled,
+      freezing:                 :freezing_stubs_enabled,
+      tainting:                 :tainting_stubs_enabled,
       const_missing:            :const_missing_enabled,
       dynamic_require_severity: :dynamic_require_severity,
       irb:                      :irb_enabled,

data/lib/opal/nodes/arglist.rb

@@ -11,25 +11,23 @@ module Opal
 
         children.each do |current|
           splat = current.first == :splat
-          arg   = expr(current)
+          arg = expr(current)
 
           if splat
             if work.empty?
               if code.empty?
-                code << fragment("[].concat(")
                 code << arg
-                code << fragment(")")
               else
-                code += ".concat(#{arg})"
+                code << fragment(".concat(") << arg << fragment(")")
               end
             else
               if code.empty?
-                code << [fragment("["), work, fragment("]")]
+                code << fragment("[") << work << fragment("]")
               else
-                code << [fragment(".concat(["), work, fragment("])")]
+                code << fragment(".concat([") << work << fragment("])")
               end
 
-              code << [fragment(".concat("), arg, fragment(")")]
+              code << fragment(".concat(") << arg << fragment(")")
             end
 
             work = []

data/lib/opal/nodes/call.rb

@@ -28,7 +28,7 @@ module Opal
         # some special methods need to skip compilation
         return unless compile_default?
 
-        compiler.method_calls << meth.to_sym
+        compiler.method_calls << meth.to_sym if record_method?
 
         # if trying to access an lvar in irb mode
         return compile_irb_var if using_irb?
@@ -36,6 +36,10 @@ module Opal
         default_compile
       end
 
+      def record_method?
+        true
+      end
+
       def default_compile
 
         mid = mid_to_jsid meth.to_s
@@ -147,6 +151,7 @@ module Opal
       OPERATORS.each do |operator, name|
         add_special(operator.to_sym) do
           if compiler.inline_operators?
+            compiler.method_calls << operator.to_sym if record_method?
             compiler.operator_helpers << operator.to_sym
             lhs, rhs = expr(recvr), expr(arglist[1])
 

data/lib/opal/nodes/call_special.rb

@@ -27,6 +27,80 @@ module Opal
       end
     end
 
+    # recv.JS[1] = rhs
+    class JsAttrAssignNode < CallNode
+      handle :jsattrasgn
+
+      def record_method?
+        false
+      end
+
+      def default_compile
+        push recv(recv_sexp), '[', expr(arglist[1]), ']', '=', expr(arglist[2])
+      end
+    end
+
+    # recv.JS.prop
+    # recv.JS[1]
+    # recv.JS.meth(arg1, arg2)
+    class JsCallNode < CallNode
+      handle :jscall
+
+      def record_method?
+        false
+      end
+
+      def default_compile
+        if meth == :[]
+          push recv(recv_sexp), '[', expr(arglist), ']'
+        else
+          mid = ".#{meth}"
+
+          splat = arglist[1..-1].any? { |a| a.first == :splat }
+
+          if Sexp === arglist.last and arglist.last.type == :block_pass
+            block = arglist.pop
+          elsif iter
+            block = iter
+          end
+
+          blktmp  = scope.new_temp if block
+          tmprecv = scope.new_temp if splat
+
+          # must do this after assigning temp variables
+          block = expr(block) if block
+
+          recv_code = recv(recv_sexp)
+          call_recv = s(:js_tmp, blktmp || recv_code)
+
+          if blktmp
+            arglist.push call_recv
+          end
+
+          args = expr(arglist)
+
+          if tmprecv
+            push "(#{tmprecv} = ", recv_code, ")#{mid}"
+          else
+            push recv_code, mid
+          end
+
+          if blktmp
+            unshift "(#{blktmp} = ", block, ", "
+            push ")"
+          end
+
+          if splat
+            push ".apply(", tmprecv, ", ", args, ")"
+          else
+            push "(", args, ")"
+          end
+
+          scope.queue_temp blktmp if blktmp
+        end
+      end
+    end
+
     # lhs =~ rhs
     # s(:match3, lhs, rhs)
     class Match3Node < Base

data/lib/opal/nodes/def.rb

@@ -38,7 +38,6 @@ module Opal
       end
 
       def compile
-        jsid = mid_to_jsid mid.to_s
         params = nil
         scope_name = nil
 
@@ -76,6 +75,10 @@ module Opal
 
           compile_block_arg
 
+          if rest_arg
+            scope.locals.delete(rest_arg[1])
+          end
+
           unshift "\n#{current_indent}", scope.to_vars
           line stmt_code
 
@@ -99,16 +102,22 @@ module Opal
         if recvr
           unshift 'Opal.defs(', recv(recvr), ", '$#{mid}', "
           push ')'
-        elsif uses_defn?(scope)
+        elsif scope.iter?
+          wrap "Opal.def(self, '$#{mid}', ", ')'
+        elsif scope.module? || scope.class?
           wrap "Opal.defn(self, '$#{mid}', ", ')'
-        elsif scope.class?
-          unshift "#{scope.proto}#{jsid} = "
         elsif scope.sclass?
-          unshift "self.$$proto#{jsid} = "
+          if scope.defs
+            unshift "Opal.defs(self, '$#{mid}', "
+          else
+            unshift "Opal.defn(self, '$#{mid}', "
+          end
+          push ')'
         elsif scope.top?
-          unshift "Opal.Object.$$proto#{jsid} = "
+          unshift "Opal.defn(Opal.Object, '$#{mid}', "
+          push ')'
         else
-          unshift "def#{jsid} = "
+          raise "Unsupported use of `def`; please file a bug at https://github.com/opal/opal reporting this message."
         end
 
         wrap '(', ", nil) && '#{mid}'" if expr?
@@ -129,7 +138,12 @@ module Opal
       def compile_rest_arg
         if rest_arg and rest_arg[1]
           splat = variable(rest_arg[1].to_sym)
-          line "#{splat} = $slice.call(arguments, #{argc});"
+          line "var array_size = arguments.length - #{argc};"
+          line "if(array_size < 0) array_size = 0;"
+          line "var #{splat} = new Array(array_size);"
+          line "for(var arg_index = 0; arg_index < array_size; arg_index++) {"
+          line "  #{splat}[arg_index] = arguments[arg_index + #{argc}];"
+          line "}"
         end
       end
 
@@ -165,6 +179,9 @@ module Opal
           line "  $kwargs = #{opt_arg_name};"
           line "  #{opt_arg_name} = ", expr(last_opt_arg[2]), ";"
           line "}"
+          line "else if ($kwargs == null) {"
+          line "  $kwargs = $hash2([], {});"
+          line "}"
         else
           line "if ($kwargs == null) {"
           line "  $kwargs = $hash2([], {});"
@@ -208,22 +225,6 @@ module Opal
         end
       end
 
-      # Simple helper to check whether this method should be defined through
-      # `Opal.defn()` runtime helper.
-      #
-      # @param [Opal::Scope] scope
-      # @returns [Boolean]
-      #
-      def uses_defn?(scope)
-        if scope.iter? or scope.module?
-          true
-        elsif scope.class? and %w(Object BasicObject).include?(scope.name)
-          true
-        else
-          false
-        end
-      end
-
       # Returns code used in debug mode to check arity of method call
       def arity_check(args, opt, splat, kwargs, block_name, mid)
         meth = mid.to_s.inspect
@@ -255,18 +256,24 @@ module Opal
 
       def compile
         done_kwargs = false
-        children.each_with_index do |child, idx|
-          next if :blockarg == child.first
-          next if :restarg == child.first and child[1].nil?
+        have_rest   = false
 
+        children.each_with_index do |child, idx|
           case child.first
           when :kwarg, :kwoptarg, :kwrestarg
             unless done_kwargs
               done_kwargs = true
-              push ', ' unless idx == 0
+              push ', ' unless idx == 0 || have_rest
               scope.add_arg '$kwargs'
               push '$kwargs'
             end
+
+          when :blockarg
+            # we ignore it because we don't need it
+
+          when :restarg
+            have_rest = true
+
           else
             child = child[1].to_sym
             push ', ' unless idx == 0

data/lib/opal/nodes/definitions.rb

@@ -18,9 +18,8 @@ module Opal
 
       children :mid
 
-      # FIXME: we should be setting method to a stub method here
       def compile
-        push "delete #{scope.proto}#{mid_to_jsid mid[1].to_s}"
+        push "Opal.udef(self, '$#{mid[1].to_s}');"
       end
     end
 
@@ -40,10 +39,9 @@ module Opal
       def compile
         if scope.class? or scope.module?
           scope.methods << "$#{new_name[1]}"
-          push "Opal.defn(self, '$#{new_name[1]}', #{scope.proto}#{old_mid})"
-        else
-          push "self.$$proto#{new_mid} = self.$$proto#{old_mid}"
         end
+
+        push "Opal.alias(self, '#{new_name[1]}', '#{old_name[1]}')"
       end
     end
 

data/lib/opal/nodes/for.rb

@@ -25,6 +25,19 @@ module Opal
             end
           end
 
+          assign.children.each do |sexp|
+            case sexp[0]
+            when :lasgn
+              add_local sexp[1]
+            when :masgn
+              if sexp[1][0] == :array
+                sexp[1][1].each do |sexp|
+                  add_local sexp[1] if sexp[0] == :lasgn
+                end
+              end
+            end
+          end
+
           iter = s(:iter, s(:lasgn, loop_var), assign)
           sexp = s(:call, value, :each, s(:arglist), iter)
           push expr(sexp)

data/lib/opal/nodes/helpers.rb

@@ -11,6 +11,12 @@ module Opal
       # ES3 reserved words that aren’t ES5.1 reserved words
       ES3_RESERVED_WORD_EXCLUSIVE = /#{REGEXP_START}(?:int|byte|char|goto|long|final|float|short|double|native|throws|boolean|abstract|volatile|transient|synchronized)#{REGEXP_END}/
 
+      # Prototype special properties.
+      PROTO_SPECIAL_PROPS = /#{REGEXP_START}(?:constructor|__proto__|__parent__|__noSuchMethod__|__count__)#{REGEXP_END}/
+
+      # Prototype special methods.
+      PROTO_SPECIAL_METHODS = /#{REGEXP_START}(?:hasOwnProperty|valueOf)#{REGEXP_END}/
+
       # Immutable properties of the global object
       IMMUTABLE_PROPS = /#{REGEXP_START}(?:NaN|Infinity|undefined)#{REGEXP_END}/
 
@@ -34,6 +40,14 @@ module Opal
         valid_name?(name.to_s) ? name : "#{name}$"
       end
 
+      def valid_ivar_name?(name)
+        not (PROTO_SPECIAL_PROPS =~ name or PROTO_SPECIAL_METHODS =~ name)
+      end
+
+      def ivar(name)
+        valid_ivar_name?(name.to_s) ? name : "#{name}$"
+      end
+
       # Converts a ruby lvar/arg name to a js identifier. Not all ruby names
       # are valid in javascript. A $ suffix is added to non-valid names.
       # varibales
@@ -48,7 +62,7 @@ module Opal
       # have a '.' prefix (for dot-calling), otherwise it will be
       # wrapped in brackets to use reference notation calling.
       def mid_to_jsid(mid)
-        if /\=|\+|\-|\*|\/|\!|\?|\<|\>|\&|\||\^|\%|\~|\[/ =~ mid.to_s
+        if /\=|\+|\-|\*|\/|\!|\?|<|\>|\&|\||\^|\%|\~|\[/ =~ mid.to_s
           "['$#{mid}']"
         else
           '.$' + mid

data/lib/opal/nodes/if.rb

@@ -10,14 +10,14 @@ module Opal
       RUBY_ENGINE_CHECK = [:call, [:const, :RUBY_ENGINE],
                               :==, [:arglist, [:str, "opal"]]]
 
+      RUBY_ENGINE_CHECK_NOT = [:call, [:const, :RUBY_ENGINE],
+                              :!=, [:arglist, [:str, "opal"]]]
+
       RUBY_PLATFORM_CHECK = [:call, [:const, :RUBY_PLATFORM],
                               :==, [:arglist, [:str, "opal"]]]
 
-      RUBY_ENGINE_CHECK_NOT = [:call, [:call, [:const, :RUBY_ENGINE], :==,
-                                [:arglist, [:str, "opal"]]], :'!', [:arglist]]
-
-      RUBY_PLATFORM_CHECK_NOT = [:call, [:call, [:const, :RUBY_PLATFORM], :==,
-                                  [:arglist, [:str, "opal"]]], :'!', [:arglist]]
+      RUBY_PLATFORM_CHECK_NOT = [:call, [:const, :RUBY_PLATFORM],
+                              :!=, [:arglist, [:str, "opal"]]]
 
       def compile
         truthy, falsy = self.truthy, self.falsy

data/lib/opal/nodes/iter.rb

@@ -65,10 +65,14 @@ module Opal
               push "if (#{arg} == null) #{arg} = nil;"
             end
           elsif arg.type == :array
+            vars = {}
             arg[1..-1].each_with_index do |_arg, _idx|
               _arg = variable(_arg[1])
-              push "var #{_arg} = #{params[idx]}[#{_idx}];"
+              unless vars.has_key?(_arg) || params.include?(_arg)
+                vars[_arg] = "#{params[idx]}[#{_idx}]"
+              end
             end
+            push "var #{ vars.map{|k, v| "#{k} = #{v}"}.join(', ') };"
           else
             raise "Bad block arg type"
           end
@@ -115,6 +119,7 @@ module Opal
         sexp.each do |arg|
           if arg[0] == :lasgn
             ref = variable(arg[1])
+            next if ref == :_ && result.include?(ref)
             self.add_arg ref
             result << ref
           elsif arg[0] == :array

data/lib/opal/nodes/literal.rb

@@ -67,7 +67,7 @@ module Opal
         case value
         when ''
           push('/(?:)/')
-        when %r{\?\<\w+\>}
+        when %r{\?<\w+\>}
           message = "named captures are not supported in javascript: #{value.inspect}"
           push "self.$raise(new SyntaxError('#{message}'))"
         else

data/lib/opal/nodes/logic.rb

@@ -96,7 +96,7 @@ module Opal
         elsif value.type == :sym
           push '[', expr(value), ']'
         else
-          push recv(value)
+          push "Opal.to_a(", recv(value), ")"
         end
       end
     end
@@ -130,7 +130,7 @@ module Opal
             push "((#{tmp} = ", truthy_opt
             push ") ? "
             push expr(rhs)
-            push " : #{tmp})"
+            push " : ", expr(lhs), ")"
           else
             push "(#{tmp} = "
             push expr(lhs)