opal 0.10.0.beta2 → 0.10.0.beta3

data/lib/opal/parser/grammar.y

@@ -225,16 +225,25 @@ rule
                       result = new_js_call(val[0], val[2], val[3])
                     }
                 | primary_value tJSDOT operation2 command_args cmd_brace_block
+                    {
+                      result = new_js_call(val[0], val[2], val[3]) << val[4]
+                    }
                 | primary_value tDOT operation2 command_args =tLOWEST
                     {
                       result = new_call(val[0], val[2], val[3])
                     }
                 | primary_value tDOT operation2 command_args cmd_brace_block
+                    {
+                      result = new_call(val[0], val[2], val[3]) << val[4]
+                    }
                 | primary_value tCOLON2 operation2 command_args =tLOWEST
-                  {
-                    result = new_call(val[0], val[2], val[3])
-                  }
+                    {
+                      result = new_call(val[0], val[2], val[3])
+                    }
                 | primary_value tCOLON2 operation2 command_args cmd_brace_block
+                    {
+                      result = new_call(val[0], val[2], val[3]) << val[4]
+                    }
                 | kSUPER command_args
                     {
                       result = new_super(val[0], val[1])
@@ -714,28 +723,15 @@ rule
                       add_block_pass result, val[0]
                     }
 
-      call_args2: arg_value tCOMMA args opt_block_arg
-                | block_arg
-
     command_args:   {
                       lexer.cmdarg_push 1
                     }
-                    open_args
+                    call_args
                     {
                       lexer.cmdarg_pop
                       result = val[1]
                     }
 
-       open_args: call_args
-                | tLPAREN_ARG tRPAREN
-                    {
-                      result = nil
-                    }
-                | tLPAREN_ARG call_args2 tRPAREN
-                    {
-                      result = val[1]
-                    }
-
        block_arg: tAMPER arg_value
                     {
                       result = new_block_pass(val[0], val[1])
@@ -799,10 +795,22 @@ rule
                     {
                       result = s(:begin, val[2])
                     }
-                | tLPAREN_ARG expr opt_nl tRPAREN
+                | tLPAREN_ARG expr
+                    {
+                      lexer.lex_state = :expr_endarg
+                    }
+                    opt_nl tRPAREN
                     {
                       result = val[1]
                     }
+                | tLPAREN_ARG
+                    {
+                      lexer.lex_state = :expr_endarg
+                    }
+                    opt_nl tRPAREN
+                    {
+                      result = new_nil(val[0])
+                    }
                 | tLPAREN compstmt tRPAREN
                     {
                       result = new_paren(val[0], val[1], val[2])
@@ -867,8 +875,7 @@ rule
                 | method_call
                 | method_call brace_block
                     {
-                      val[0] << val[1]
-                      result = val[0]
+                      result = new_method_call_with_block(val[0], val[1])
                     }
                 | tLAMBDA lambda
                     {
@@ -1168,6 +1175,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                     }
                 | f_arg tCOMMA
                     {
+                      val[0] << nil
                       result = [val[0], nil]
                     }
                 | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_block_args_tail

data/lib/opal/parser/lexer.rb

@@ -653,7 +653,7 @@ module Opal
           elsif cmdarg? && @lex_state != :expr_cmdarg
             @lex_state = :expr_beg
             return :kDO_BLOCK
-          elsif @lex_state == :expr_endarg
+          elsif last_state == :expr_endarg
             return :kDO_BLOCK
           else
             @lex_state = :expr_beg
@@ -997,7 +997,6 @@ module Opal
 
         elsif scan(/\(/)
           result = scanner.matched
-          @lparen_arg_seen = false
 
           if beg?
             result = :tLPAREN
@@ -1018,6 +1017,7 @@ module Opal
           cond_lexpop
           cmdarg_lexpop
           @lex_state = :expr_end
+          @lparen_arg_seen = false
           return :tRPAREN
 
         elsif scan(/\[/)
@@ -1304,7 +1304,7 @@ module Opal
               result = :tLCURLY
             end
           elsif @lex_state == :expr_endarg
-            result = :LBRACE_ARG
+            result = :tLBRACE_ARG
           else
             result = :tLBRACE
           end
@@ -1328,7 +1328,7 @@ module Opal
         elsif check(/[0-9]/)
           return process_numeric
 
-        elsif scan(IDENTIFIER_REGEXP)
+        elsif scan(INLINE_IDENTIFIER_REGEXP)
           return process_identifier scanner.matched, cmd_start
         end
 

data/lib/opal/regexp_anchors.rb

@@ -2,6 +2,15 @@ module Opal
   REGEXP_START = RUBY_ENGINE == 'opal' ? '^' : '\A'.freeze
   REGEXP_END = RUBY_ENGINE == 'opal' ? '$' : '\z'.freeze
 
+  # Unicode characters in ranges
+  # \u0001 - \u002F (blank unicode characters + space + !"#$%&'()*+,-./ chars)
+  # \u003A - \u0040 (:;<=>?@ chars)
+  # \u005B - \u005E ([\]^ chars)
+  # \u0060          (` char)
+  # \u007B - \u007F ({|}~ chars})
+  # are not allowed to be used in identifier in the beggining or middle of its name
+  FORBIDDEN_STARTING_IDENTIFIER_CHARS = "\\u0001-\\u002F\\u003A-\\u0040\\u005B-\\u005E\\u0060\\u007B-\\u007F"
+
   # Unicode characters in ranges
   # \u0001 - \u0020 (blank unicode characters + space)
   # \u0022 - \u002F ("#$%&'()*+,-./ chars)
@@ -10,14 +19,13 @@ module Opal
   # \u005B - \u005E ([\]^ chars)
   # \u0060          (` char)
   # \u007B - \u007F ({|}~ chars})
-  # are not allowed to be used in identifier in any form
-  # This regexp contains a common rule for filtering Ruby identifiers
-  FORBIDDEN_IDENTIFIER_CHARS = "\\u0001-\\u0020\\u0022-\\u002F\\u003A-\\u003E\\u0040\\u005B-\\u005E\\u0060\\u007B-\\u007F"
-  IDENTIFIER_REGEXP = Regexp.new("[^#{FORBIDDEN_IDENTIFIER_CHARS}]+")
+  # are not allowed to be used in identifier in the end of its name
+  # In fact, FORBIDDEN_STARTING_IDENTIFIER_CHARS = FORBIDDEN_ENDING_IDENTIFIER_CHARS + \u0021 ('?') + \u003F ('!')
+  FORBIDDEN_ENDING_IDENTIFIER_CHARS   = "\\u0001-\\u0020\\u0022-\\u002F\\u003A-\\u003E\\u0040\\u005B-\\u005E\\u0060\\u007B-\\u007F"
+  INLINE_IDENTIFIER_REGEXP = Regexp.new("[^#{FORBIDDEN_STARTING_IDENTIFIER_CHARS}]*[^#{FORBIDDEN_ENDING_IDENTIFIER_CHARS}]")
 
   # For constants rules are pretty much the same, but ':' is allowed and '?!' are not.
   # Plus it may start with a '::' which indicates that the constant comes from toplevel.
   FORBIDDEN_CONST_NAME_CHARS = "\\u0001-\\u0020\\u0021-\\u002F\\u003B-\\u003F\\u0040\\u005B-\\u005E\\u0060\\u007B-\\u007F"
   CONST_NAME_REGEXP = Regexp.new("#{REGEXP_START}(::)?[A-Z][^#{FORBIDDEN_CONST_NAME_CHARS}]*#{REGEXP_END}")
 end
-

data/lib/opal/source_map.rb

@@ -29,7 +29,8 @@ module Opal
             mapping = ::SourceMap::Mapping.new(
               source_file,
               generated_offset,
-              source_offset
+              source_offset,
+              fragment.source_map_name
             )
           end
 

data/lib/opal/version.rb

@@ -1,5 +1,5 @@
 module Opal
   # WHEN RELEASING:
   # Remember to update RUBY_ENGINE_VERSION in opal/corelib/constants.rb too!
-  VERSION = '0.10.0.beta2'
+  VERSION = '0.10.0.beta3'
 end

data/opal/corelib/array.rb

@@ -2227,4 +2227,8 @@ class Array < `Array`
       }
     }
   end
+
+  def instance_variables
+    super.reject { |ivar| `/^@\d+$/.test(#{ivar})` || ivar == '@length' }
+  end
 end

data/opal/corelib/basic_object.rb

@@ -51,7 +51,9 @@ class BasicObject
       Kernel.raise ArgumentError, "wrong number of arguments (0 for 1..3)" unless (1..3).cover? args.size
 
       string, file, _lineno = *args
-      compiled = Opal.compile string, file: (file || '(eval)'), eval: true
+      default_eval_options = { file: (file || '(eval)'), eval: true }
+      compiling_options = __OPAL_COMPILER_CONFIG__.merge(default_eval_options)
+      compiled = Opal.compile string, compiling_options
       block = Kernel.lambda do
         %x{
           return (function(self) {

data/opal/corelib/constants.rb

@@ -1,7 +1,7 @@
 RUBY_PLATFORM       = 'opal'
 RUBY_ENGINE         = 'opal'
 RUBY_VERSION        = '2.2.3'
-RUBY_ENGINE_VERSION = '0.10.0.beta2'
+RUBY_ENGINE_VERSION = '0.10.0.beta3'
 RUBY_RELEASE_DATE   = '2015-12-20'
 RUBY_PATCHLEVEL     = 0
 RUBY_REVISION       = 0

data/opal/corelib/file.rb

@@ -22,12 +22,204 @@ class File < IO
     end
     alias realpath expand_path
 
+    %x{
+      function chompdirsep(path) {
+        var last;
+
+        while (path.length > 0) {
+          if (isDirSep(path)) {
+            last = path;
+            path = path.substring(1, path.length);
+            while (path.length > 0 && isDirSep(path)) {
+              path = inc(path);
+            }
+            if (path.length == 0) {
+              return last;
+            }
+          }
+          else {
+            path = inc(path);
+          }
+        }
+        return path;
+      }
+
+      function inc(a) {
+        return a.substring(1, a.length);
+      }
+
+      function skipprefix(path) {
+        return path;
+      }
+
+      function lastSeparator(path) {
+        var tmp, last;
+
+        while (path.length > 0) {
+          if (isDirSep(path)) {
+            tmp = path;
+            path = inc(path);
+
+            while (path.length > 0 && isDirSep(path)) {
+              path = inc(path);
+            }
+            if (!path) {
+              break;
+            }
+            last = tmp;
+          }
+          else {
+            path = inc(path);
+          }
+        }
+
+        return last;
+      }
+
+      function isDirSep(sep) {
+        return sep.charAt(0) === #{SEPARATOR};
+      }
+
+      function skipRoot(path) {
+        while (path.length > 0 && isDirSep(path)) {
+          path = inc(path);
+        }
+        return path;
+      }
+
+      function pointerSubtract(a, b) {
+        if (a.length == 0) {
+          return b.length;
+        }
+        return b.indexOf(a);
+      }
+
+      function handleSuffix(n, f, p, suffix, name, origName) {
+        var suffixMatch;
+
+        if (n >= 0) {
+          if (suffix === nil) {
+            f = n;
+          }
+          else {
+            suffixMatch = suffix === '.*' ? '\\.\\w+' : suffix.replace(/\?/g, '\\?');
+            suffixMatch = new RegExp(suffixMatch + #{Separator} + '*$').exec(p);
+            if (suffixMatch) {
+              f = suffixMatch.index;
+            }
+            else {
+              f = n;
+            }
+          }
+
+          if (f === origName.length) {
+            return name;
+          }
+        }
+
+        return p.substring(0, f);
+      }
+    }
+
     def dirname(path)
-      split(path)[0..-2].join(SEPARATOR)
+      %x{
+        if (path === nil) {
+          #{raise TypeError, 'no implicit conversion of nil into String'}
+        }
+        if (#{path.respond_to?(:to_path)}) {
+          path = #{path.to_path};
+        }
+        if (!path.$$is_string) {
+          #{raise TypeError, "no implicit conversion of #{path.class} into String"}
+        }
+
+        var root, p;
+
+        root = skipRoot(path);
+
+        // if (root > name + 1) in the C code
+        if (root.length == 0) {
+          path = path.substring(path.length - 1, path.length);
+        }
+        else if (root.length - path.length < 0) {
+          path = path.substring(path.indexOf(root)-1, path.length);
+        }
+
+        p = lastSeparator(root);
+        if (!p) {
+          p = root;
+        }
+        if (p === path) {
+          return '.';
+        }
+        return path.substring(0, path.length - p.length);
+      }
     end
 
-    def basename(path)
-      split(path)[-1]
+    def basename(name, suffix=nil)
+      %x{
+        var p, q, e, f = 0, n = -1, tmp, pointerMath, origName;
+
+        if (name === nil) {
+          #{raise TypeError, 'no implicit conversion of nil into String'}
+        }
+        if (#{name.respond_to?(:to_path)}) {
+          name = #{name.to_path};
+        }
+        if (!name.$$is_string) {
+          #{raise TypeError, "no implicit conversion of #{name.class} into String"}
+        }
+        if (suffix !== nil && !suffix.$$is_string) {
+          #{raise TypeError, "no implicit conversion of #{suffix.class} into String"}
+        }
+
+        if (name.length == 0) {
+          return name;
+        }
+
+        origName = name;
+        name = skipprefix(name);
+
+        while (isDirSep(name)) {
+          tmp = name;
+          name = inc(name);
+        }
+
+        if (!name) {
+          p = tmp;
+          f = 1;
+        }
+        else {
+          if (!(p = lastSeparator(name))) {
+            p = name;
+          }
+          else {
+            while (isDirSep(p)) {
+              p = inc(p);
+            }
+          }
+
+          n = pointerSubtract(chompdirsep(p), p);
+
+          for (q = p; pointerSubtract(q, p) < n && q.charAt(0) === '.'; q = inc(q)) {
+          }
+
+          for (e = null; pointerSubtract(q, p) < n; q = inc(q)) {
+            if (q.charAt(0) === '.') {
+              e = q;
+            }
+          }
+
+          if (e) {
+            f = pointerSubtract(e, p);
+          }
+          else {
+            f = n;
+          }
+        }
+
+        return handleSuffix(n, f, p, suffix, name, origName);
+      }
     end
 
     def extname(path)
@@ -35,7 +227,7 @@ class File < IO
       path = path.to_path if path.respond_to?(:to_path)
       raise TypeError, "no implicit conversion of #{path.class} into String" unless path.is_a?(String)
       filename = basename(path)
-      return '' if filename.nil?
+      return '' if filename.empty?
       last_dot_idx = filename[1..-1].rindex('.')
       # extension name must contains at least one character .(something)
       (last_dot_idx.nil? || last_dot_idx + 1 == filename.length - 1) ? '' : filename[(last_dot_idx + 1)..-1]

data/opal/corelib/hash.rb

@@ -175,7 +175,7 @@ class Hash
   end
 
   def default(key = undefined)
-     %x{
+    %x{
       if (key !== undefined && self.$$proc !== nil && self.$$proc !== undefined) {
         return self.$$proc.$call(self, key);
       }
@@ -196,12 +196,12 @@ class Hash
   end
 
   def default_proc
-     %x{
-       if (self.$$proc !== undefined) {
-         return self.$$proc;
-       }
-       return nil;
-     }
+    %x{
+      if (self.$$proc !== undefined) {
+        return self.$$proc;
+      }
+      return nil;
+    }
   end
 
   def default_proc=(proc)