opal 1.3.1 → 1.4.1

data/lib/opal/nodes/top.rb

@@ -13,33 +13,40 @@ module Opal
       children :body
 
       def compile
+        compiler.top_scope = self
+
         push version_comment
 
         in_scope do
-          line '"use strict";' if compiler.use_strict?
+          if body == s(:nil)
+            # A shortpath for empty (stub?) modules.
+            line 'return Opal.nil;'
+          else
+            line '"use strict";' if compiler.use_strict?
 
-          body_code = stmt(stmts)
-          body_code = [body_code] unless body_code.is_a?(Array)
+            body_code = stmt(stmts)
+            body_code = [body_code] unless body_code.is_a?(Array)
 
-          if compiler.eval?
-            add_temp '$nesting = self.$$is_a_module ? [self] : [self.$$class]'
-          else
-            add_temp 'self = Opal.top'
-            add_temp '$nesting = []'
-          end
-          add_temp 'nil = Opal.nil'
-          add_temp '$$$ = Opal.$$$'
-          add_temp '$$ = Opal.$$'
+            if compiler.eval?
+              add_temp '$nesting = self.$$is_a_module ? [self] : [self.$$class]' if @define_nesting
+            else
+              add_temp 'self = Opal.top' if @define_self
+              add_temp '$nesting = []' if @define_nesting
+            end
+            add_temp '$$ = Opal.$r($nesting)' if @define_relative_access
+
+            add_temp 'nil = Opal.nil'
+            add_temp '$$$ = Opal.$$$' if @define_absolute_const
 
-          add_used_helpers
-          add_used_operators
-          line scope.to_vars
+            add_used_helpers
+            line scope.to_vars
 
-          compile_method_stubs
-          compile_irb_vars
-          compile_end_construct
+            compile_method_stubs
+            compile_irb_vars
+            compile_end_construct
 
-          line body_code
+            line body_code
+          end
         end
         opening
         closing
@@ -73,6 +80,12 @@ module Opal
         compiler.returns(body)
       end
 
+      # Returns '$$$', but also ensures that the '$$$' variable is set
+      def absolute_const
+        @define_absolute_const = true
+        '$$$'
+      end
+
       def compile_irb_vars
         if compiler.irb?
           line 'if (!Opal.irb_vars) { Opal.irb_vars = {}; }'
@@ -83,21 +96,11 @@ module Opal
         compiler.helpers.to_a.each { |h| add_temp "$#{h} = Opal.#{h}" }
       end
 
-      def add_used_operators
-        operators = compiler.operator_helpers.to_a
-        operators.each do |op|
-          name = Nodes::CallNode::OPERATORS[op]
-          line "function $rb_#{name}(lhs, rhs) {"
-          line "  return (typeof(lhs) === 'number' && typeof(rhs) === 'number') ? lhs #{op} rhs : lhs['$#{op}'](rhs);"
-          line '}'
-        end
-      end
-
       def compile_method_stubs
         if compiler.method_missing?
           calls = compiler.method_calls
-          stubs = calls.to_a.map { |k| "'$#{k}'" }.join(', ')
-          line "Opal.add_stubs([#{stubs}]);" unless stubs.empty?
+          stubs = calls.to_a.map(&:to_s).join(',')
+          line "Opal.add_stubs('#{stubs}');" unless stubs.empty?
         end
       end
 

data/lib/opal/nodes/variables.rb

@@ -70,7 +70,7 @@ module Opal
       def compile
         name = property(var_name)
         add_ivar name
-        push "self#{name}"
+        push "#{scope.self}#{name}"
       end
     end
 
@@ -85,7 +85,7 @@ module Opal
 
       def compile
         name = property(var_name)
-        push "self#{name} = "
+        push "#{scope.self}#{name} = "
         push expr(value)
 
         wrap '(', ')' if (recv? || expr?) && value

data/lib/opal/nodes/x_string.rb

@@ -8,9 +8,9 @@ module Opal
       def compile
         @should_add_semicolon = false
         unpacked_children = unpack_return(children)
-        stripped_children = strip_empty_children(unpacked_children)
+        stripped_children = XStringNode.strip_empty_children(unpacked_children)
 
-        if single_line?(stripped_children)
+        if XStringNode.single_line?(stripped_children)
           # If it's a single line we'll try to:
           #
           # - strip empty lines
@@ -30,6 +30,31 @@ module Opal
         push ';' if @should_add_semicolon
       end
 
+      # Check if there's only one child or if they're all part of
+      # the same line (e.g. because of interpolations)
+      def self.single_line?(children)
+        (children.size == 1) || children.none? do |c|
+          c.type == :str && c.loc.expression.source.end_with?("\n")
+        end
+      end
+
+      # Will remove empty :str lines coming from cosmetic newlines in x-strings
+      #
+      # @example
+      #   # this will generate two additional empty
+      #   # children before and after `foo()`
+      #   %x{
+      #     foo()
+      #   }
+      def self.strip_empty_children(children)
+        children = children.dup
+        empty_line = ->(child) { child.nil? || (child.type == :str && child.loc.expression.source.rstrip.empty?) }
+
+        children.shift while children.any? && empty_line[children.first]
+        children.pop while children.any? && empty_line[children.last]
+
+        children
+      end
 
       private
 
@@ -37,6 +62,7 @@ module Opal
         case child.type
         when :str
           value = child.loc.expression.source
+          scope.self if value.include? 'self'
           push Fragment.new(value, scope, child)
         when :begin, :gvar, :ivar, :nil
           push expr(child)
@@ -81,6 +107,8 @@ module Opal
       def extract_last_value(last_child)
         last_value = last_child.loc.expression.source.rstrip
 
+        scope.self if last_value.include? 'self'
+
         if (@returning || expr?) && last_value.end_with?(';')
           compiler.warning(
             'Removed semicolon ending x-string expression, interpreted as unintentional',
@@ -94,14 +122,6 @@ module Opal
         last_value
       end
 
-      # Check if there's only one child or if they're all part of
-      # the same line (e.g. because of interpolations)
-      def single_line?(children)
-        (children.size == 1) || children.none? do |c|
-          c.type == :str && c.loc.expression.source.end_with?("\n")
-        end
-      end
-
       # A case for manually created :js_return statement in Compiler#returns
       # Since we need to take original source of :str we have to use raw source
       # so we need to combine "return" with "raw_source"
@@ -116,24 +136,6 @@ module Opal
 
         children
       end
-
-      # Will remove empty :str lines coming from cosmetic newlines in x-strings
-      #
-      # @example
-      #   # this will generate two additional empty
-      #   # children before and after `foo()`
-      #   %x{
-      #     foo()
-      #   }
-      def strip_empty_children(children)
-        children = children.dup
-        empty_line = ->(child) { child.nil? || (child.type == :str && child.loc.expression.source.rstrip.empty?) }
-
-        children.shift while children.any? && empty_line[children.first]
-        children.pop while children.any? && empty_line[children.last]
-
-        children
-      end
     end
   end
 end

data/lib/opal/nodes.rb

@@ -20,7 +20,6 @@ require 'opal/nodes/logic'
 require 'opal/nodes/definitions'
 require 'opal/nodes/yield'
 require 'opal/nodes/rescue'
-require 'opal/nodes/case'
 require 'opal/nodes/super'
 require 'opal/nodes/top'
 require 'opal/nodes/while'

data/lib/opal/parser/patch.rb

@@ -48,6 +48,81 @@ if RUBY_ENGINE == 'opal'
         diagnostic :error, :lvar_name, { name: name }, loc
       end
     end
+
+    # Taken From:
+    # https://github.com/whitequark/parser/blob/a7c638b7b205db9213a56897b41a8e5620df766e/lib/parser/builders/default.rb#L388
+    def dedent_string(node, dedent_level)
+      unless dedent_level.nil?
+        dedenter = ::Parser::Lexer::Dedenter.new(dedent_level)
+
+        case node.type
+        when :str
+          node = node.updated(nil, [dedenter.dedent(node.children.first)])
+        when :dstr, :xstr
+          children = node.children.map do |str_node|
+            if str_node.type == :str
+              str_node = str_node.updated(nil, [dedenter.dedent(str_node.children.first)])
+              next nil if str_node.children.first.empty?
+            else
+              dedenter.interrupt
+            end
+            str_node
+          end
+
+          node = node.updated(nil, children.compact)
+        end
+      end
+
+      node
+    end
+  end
+
+  class Parser::Lexer::Dedenter
+    # Taken From:
+    # https://github.com/whitequark/parser/blob/b7a08031523d05b2f76b0bab22fac00b1d3fe653/lib/parser/lexer/dedenter.rb#L36
+    def dedent(string)
+      original_encoding = string.encoding
+      # Prevent the following error when processing binary encoded source.
+      # "\xC0".split # => ArgumentError (invalid byte sequence in UTF-8)
+      lines = string.force_encoding(Encoding::BINARY).split("\\\n")
+      if lines.length == 1
+        # If the line continuation sequence was found but there is no second
+        # line, it was not really a line continuation and must be ignored.
+        lines = [string.force_encoding(original_encoding)]
+      else
+        lines.map! { |s| s.force_encoding(original_encoding) }
+      end
+
+      lines.each_with_index do |line, index|
+        next if (index == 0) && !@at_line_begin
+        left_to_remove = @dedent_level
+        remove = 0
+
+        line.each_char do |char|
+          break if left_to_remove <= 0
+          case char
+          when "\s"
+            remove += 1
+            left_to_remove -= 1
+          when "\t"
+            break if TAB_WIDTH * (remove / TAB_WIDTH + 1) > @dedent_level
+            remove += 1
+            left_to_remove -= TAB_WIDTH
+          else
+            # no more spaces or tabs
+            break
+          end
+        end
+
+        lines[index] = line[remove..-1]
+      end
+
+      string = lines.join
+
+      @at_line_begin = string.end_with?("\n")
+
+      string
+    end
   end
 end
 

data/lib/opal/parser/with_ruby_lexer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Opal::Parser::WithRubyLexer < Parser::Ruby30
+class Opal::Parser::WithRubyLexer < Parser::Ruby31
   include Opal::Parser::DefaultConfig
   Opal::Parser.default_parser_class = self
 end

data/lib/opal/regexp_anchors.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Opal
-  REGEXP_START = RUBY_ENGINE == 'opal' ? '^' : '\A'
-  REGEXP_END = RUBY_ENGINE == 'opal' ? '$' : '\z'
+  self::REGEXP_START = RUBY_ENGINE == 'opal' ? '^' : '\A'
+  self::REGEXP_END = RUBY_ENGINE == 'opal' ? '$' : '\z'
 
   # Unicode characters in ranges
   # \u0001 - \u002F (blank unicode characters + space + !"#$%&'()*+,-./ chars)
@@ -11,7 +11,7 @@ module Opal
   # \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'
+  self::FORBIDDEN_STARTING_IDENTIFIER_CHARS = '\u0001-\u002F\u003A-\u0040\u005B-\u005E\u0060\u007B-\u007F'
 
   # Unicode characters in ranges
   # \u0001 - \u0020 (blank unicode characters + space)
@@ -23,11 +23,11 @@ module Opal
   # \u007B - \u007F ({|}~ 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}]")
+  self::FORBIDDEN_ENDING_IDENTIFIER_CHARS   = '\u0001-\u0020\u0022-\u002F\u003A-\u003E\u0040\u005B-\u005E\u0060\u007B-\u007F'
+  self::INLINE_IDENTIFIER_REGEXP = Regexp.new("[^#{self::FORBIDDEN_STARTING_IDENTIFIER_CHARS}]*[^#{self::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}")
+  self::FORBIDDEN_CONST_NAME_CHARS = '\u0001-\u0020\u0021-\u002F\u003B-\u003F\u0040\u005B-\u005E\u0060\u007B-\u007F'
+  self::CONST_NAME_REGEXP = Regexp.new("#{self::REGEXP_START}(::)?[A-Z][^#{self::FORBIDDEN_CONST_NAME_CHARS}]*#{self::REGEXP_END}")
 end

data/lib/opal/requires.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'opal/config'
+require 'opal/compiler'
+require 'opal/builder'
+require 'opal/builder_processors'
+require 'opal/erb'
+require 'opal/paths'
+require 'opal/version'
+require 'opal/errors'
+require 'opal/source_map'
+require 'opal/deprecations'
+
+# Opal is a ruby to javascript compiler, with a runtime for running
+# in any JavaScript environment.
+module Opal
+  autoload :Server, 'opal/server' if RUBY_ENGINE != 'opal'
+  autoload :SimpleServer, 'opal/simple_server'
+end

data/lib/opal/rewriters/pattern_matching.rb

@@ -60,7 +60,7 @@ module Opal
       # raise NoMatchingPatternError, from
       def raise_no_matching_pattern_error(from)
         s(:send, nil, :raise,
-          s(:const, nil, :NoMatchingPatternError),
+          s(:const, s(:cbase), :NoMatchingPatternError),
           s(:lvar, from)
         )
       end

data/lib/opal/rewriters/returnable_logic.rb

@@ -11,22 +11,120 @@ module Opal
         "$ret_or_#{@counter}"
       end
 
+      def free_tmp
+        @counter -= 1
+      end
+
       def reset_tmp_counter!
         @counter = nil
       end
 
+      def on_if(node)
+        test, = *node.children
+        # The if_test metadata signifies that we don't care about the return value except if it's
+        # truthy or falsy. And those tests will be carried out by the respective $truthy helper calls.
+        test.meta[:if_test] = true if test
+        super
+      end
+
+      def on_case(node)
+        lhs, *whens, els = *node.children
+        els ||= s(:nil)
+        lhs_tmp = next_tmp if lhs
+
+        out = build_if_from_when(node, lhs, lhs_tmp, whens, els)
+        free_tmp if lhs
+        out
+      end
+
+      # `a || b` / `a or b`
       def on_or(node)
         lhs, rhs = *node.children
-        lhs_tmp = next_tmp
 
-        node.updated(:if, [s(:lvasgn, lhs_tmp, process(lhs)), s(:js_tmp, lhs_tmp), process(rhs)])
+        if node.meta[:if_test]
+          # Let's forward the if_test to the lhs and rhs - since we don't care about the exact return
+          # value of our or, we neither do care about a return value of our lhs or rhs.
+          lhs.meta[:if_test] = rhs.meta[:if_test] = true
+          out = process(node.updated(:if, [lhs, s(:true), rhs]))
+        else
+          lhs_tmp = next_tmp
+          out = process(node.updated(:if, [s(:lvasgn, lhs_tmp, lhs), s(:js_tmp, lhs_tmp), rhs]))
+          free_tmp
+        end
+        out
       end
 
+      # `a && b` / `a and b`
       def on_and(node)
         lhs, rhs = *node.children
-        lhs_tmp = next_tmp
 
-        node.updated(:if, [s(:lvasgn, lhs_tmp, process(lhs)), process(rhs), s(:js_tmp, lhs_tmp)])
+        if node.meta[:if_test]
+          lhs.meta[:if_test] = rhs.meta[:if_test] = true
+          out = process(node.updated(:if, [lhs, rhs, s(:false)]))
+        else
+          lhs_tmp = next_tmp
+          out = process(node.updated(:if, [s(:lvasgn, lhs_tmp, lhs), rhs, s(:js_tmp, lhs_tmp)]))
+          free_tmp
+        end
+        out
+      end
+
+      # Parser sometimes generates parentheses as a begin node. If it's a single node begin value, then
+      # let's forward the if_test metadata.
+      def on_begin(node)
+        if node.meta[:if_test] && node.children.count == 1
+          node.children.first.meta[:if_test] = true
+        end
+        node.meta.delete(:if_test)
+        super
+      end
+
+      private
+
+      def build_if_from_when(node, lhs, lhs_tmp, whens, els)
+        first_when, *next_whens = *whens
+
+        *parts, expr = *first_when.children
+
+        rule = build_rule_from_parts(node, lhs, lhs_tmp, parts)
+
+        first_when.updated(:if, [rule, process(expr), next_whens.empty? ? process(els) : build_if_from_when(nil, nil, lhs_tmp, next_whens, els)])
+      end
+
+      def build_rule_from_parts(node, lhs, lhs_tmp, parts)
+        lhs = if node && lhs_tmp
+                node.updated(:lvasgn, [lhs_tmp, process(lhs)])
+              else
+                s(:js_tmp, lhs_tmp)
+              end
+
+        first_part, *next_parts = *parts
+
+        subrule = if first_part.type == :splat
+                    splat_on = first_part.children.first
+                    iter_val = next_tmp
+                    block = s(:send, process(splat_on), :any?,
+                      s(:iter,
+                        s(:args, s(:arg, iter_val)),
+                        build_rule_from_parts(nil, nil, lhs_tmp, [s(:lvar, iter_val)])
+                      )
+                    )
+                    if node && lhs_tmp
+                      s(:begin, lhs, block)
+                    else
+                      block
+                    end
+                  elsif lhs_tmp
+                    s(:send, process(first_part), :===, lhs)
+                  else
+                    process(first_part)
+                  end
+
+        if next_parts.empty?
+          subrule
+        else
+          s(:if, subrule, s(:true), build_rule_from_parts(nil, nil, lhs_tmp, next_parts))
+        end
       end
     end
   end

data/lib/opal/util.rb

@@ -14,8 +14,8 @@ module Opal
     #
     # @param str [String] string to minify
     # @return [String]
-    def uglify(source)
-      sh 'bin/yarn -s run terser -c', data: source
+    def uglify(source, mangle: false)
+      sh "bin/yarn -s run terser -c #{'-m' if mangle}", data: source
     end
 
     # Gzip code to check file size.

data/lib/opal/version.rb

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

data/lib/opal.rb

@@ -1,19 +1,3 @@
 # frozen_string_literal: true
 
-require 'opal/config'
-require 'opal/compiler'
-require 'opal/builder'
-require 'opal/builder_processors'
-require 'opal/erb'
-require 'opal/paths'
-require 'opal/version'
-require 'opal/errors'
-require 'opal/source_map'
-require 'opal/deprecations'
-
-# Opal is a ruby to javascript compiler, with a runtime for running
-# in any JavaScript environment.
-module Opal
-  autoload :Server, 'opal/server'
-  autoload :SimpleServer, 'opal/simple_server'
-end
+require 'opal/requires'

data/opal/corelib/array/pack.rb

@@ -2,7 +2,7 @@
 
 require 'corelib/pack_unpack/format_string_parser'
 
-class Array
+class ::Array
   %x{
     // Format Parser
     var eachDirectiveAndCount = Opal.PackUnpack.eachDirectiveAndCount;
@@ -93,7 +93,7 @@ class Array
         var buffer = callback(data);
 
         return buffer.map(function(item) {
-          return $coerce_to(item, #{Integer}, 'to_int')
+          return $coerce_to(item, #{::Integer}, 'to_int')
         });
       }
     }
@@ -103,7 +103,7 @@ class Array
         var buffer = callback(data);
 
         return buffer.map(function(item) {
-          return $coerce_to(item, #{String}, 'to_str')
+          return $coerce_to(item, #{::String}, 'to_str')
         });
       }
     }
@@ -116,7 +116,7 @@ class Array
             return String.fromCodePoint(item);
           } catch (error) {
             if (error instanceof RangeError) {
-              #{raise RangeError, 'value out of range'};
+              #{::Kernel.raise ::RangeError, 'value out of range'};
             }
             throw error;
           }
@@ -199,7 +199,7 @@ class Array
           }
         } else {
           if (buffer.length < count) {
-            #{raise ArgumentError, 'too few arguments'};
+            #{::Kernel.raise ::ArgumentError, 'too few arguments'};
           }
           for (var i = 0; i < count; i++) {
             chunkData = callback(buffer);
@@ -225,9 +225,9 @@ class Array
         if (source === nil) {
           source = '';
         } else if (source === undefined) {
-          #{raise ArgumentError, 'too few arguments'};
+          #{::Kernel.raise ::ArgumentError, 'too few arguments'};
         } else {
-          source = $coerce_to(source, #{String}, 'to_str');
+          source = $coerce_to(source, #{::String}, 'to_str');
         }
 
         buffer = buffer.slice(1, buffer.length);
@@ -388,7 +388,7 @@ class Array
   }
 
   def pack(format)
-    format = Opal.coerce_to!(format, String, :to_str).gsub(/\s/, '').delete("\000")
+    format = ::Opal.coerce_to!(format, ::String, :to_str).gsub(/\s/, '').delete("\000")
 
     %x{
       var output = '';
@@ -408,7 +408,7 @@ class Array
             chunkReader = readChunk[directive];
 
         if (chunkReader == null) {
-          #{raise "Unsupported pack directive #{`directive`.inspect} (no chunk reader defined)"}
+          #{::Kernel.raise "Unsupported pack directive #{`directive`.inspect} (no chunk reader defined)"}
         }
 
         var chunkData = chunkReader(buffer, count);
@@ -418,7 +418,7 @@ class Array
         var handler = handlers[directive];
 
         if (handler == null) {
-          #{raise "Unsupported pack directive #{`directive`.inspect} (no handler defined)"}
+          #{::Kernel.raise "Unsupported pack directive #{`directive`.inspect} (no handler defined)"}
         }
 
         return handler(chunk);
@@ -431,7 +431,7 @@ class Array
           var shouldAutocomplete = autocompletion[directive]
 
           if (shouldAutocomplete == null) {
-            #{raise "Unsupported pack directive #{`directive`.inspect} (no autocompletion rule defined)"}
+            #{::Kernel.raise "Unsupported pack directive #{`directive`.inspect} (no autocompletion rule defined)"}
           }
 
           if (shouldAutocomplete) {