ruby2js 3.0.15 → 3.3.0

data/lib/ruby2js/converter/opasgn.rb

@@ -12,7 +12,7 @@ module Ruby2JS
       var = s(:lvar, var.children.first) if var.type == :lvasgn
       var = s(:cvar, var.children.first) if var.type == :cvasgn
 
-      if 
+      if \
         [:+, :-].include?(op) and value.type==:int and 
         (value.children==[1] or value.children==[-1])
       then
@@ -46,7 +46,10 @@ module Ruby2JS
       vtype = :ivar if asgn.type == :ivasgn
       vtype = :cvar if asgn.type == :cvasgn
       
-      if vtype
+      if es2021
+        op = type == :and ? '&&' : (@or == :nullish ? '??' : '||')
+        parse s(:op_asgn, asgn, op, value);
+      elsif vtype
         parse s(asgn.type, asgn.children.first, s(type, 
           s(vtype, asgn.children.first), value))
       elsif asgn.type == :send and asgn.children[1] == :[]

data/lib/ruby2js/converter/regexp.rb

@@ -27,10 +27,35 @@ module Ruby2JS
         end
       end
 
+      # in Ruby regular expressions, ^ and $ apply to each line
       if parts.first.type == :str and parts.first.children[0].start_with?('^')
-        opts = opts + [:m] unless opts.include? :m or opts.include? 'm'
+        if opts.include? :m or opts.include? 'm'
+          if parts.first.children[0].gsub(/\\./, '').gsub(/\[.*?\]/, '').include? '.'
+            opts = opts + [:s] unless opts.include? :s or opts.include? 's'
+          end
+        else
+          opts = opts + [:m]
+        end
       elsif parts.last.type == :str and parts.last.children[0].end_with?('$')
-        opts = opts + [:m] unless opts.include? :m or opts.include? 'm'
+        if opts.include? :m or opts.include? 'm'
+          if parts.last.children[0].gsub(/\\./, '').gsub(/\[.*?\]/, '').include? '.'
+            opts = opts + [:s] unless opts.include? :s or opts.include? 's'
+          end
+        else
+          opts = opts + [:m]
+        end
+      end
+
+      # in Ruby regular expressions, /A is the start of the string
+      if parts.first.type == :str and parts.first.children[0].start_with?('\A')
+        parts = [s(:str, parts.first.children[0].sub('\A', '^'))] +
+          parts[1..-1]
+      end
+
+      # in Ruby regular expressions, /z is the end of the string
+      if parts.last.type == :str and parts.last.children[0].end_with?('\z')
+        parts = parts[0..-2] +
+          [s(:str, parts.first.children[0].sub('\z', '$'))]
       end
 
       # use slash syntax if there are few embedded slashes in the regexp

data/lib/ruby2js/converter/return.rb

@@ -14,7 +14,7 @@ module Ruby2JS
 
     EXPRESSIONS = [ :array, :float, :hash, :int, :lvar, :nil, :send, :attr,
       :str, :sym, :dstr, :dsym, :cvar, :ivar, :zsuper, :super, :or, :and,
-      :block, :const, :true, :false ]
+      :block, :const, :true, :false, :xnode ]
 
     handle :autoreturn do |*statements|
       return if statements == [nil]

data/lib/ruby2js/converter/send.rb

@@ -16,12 +16,26 @@ module Ruby2JS
     handle :send, :sendw, :await, :attr, :call do |receiver, method, *args|
       ast = @ast
 
-    if 
-      args.length == 1 and method == :+
-    then
-      node = collapse_strings(ast)
-      return parse node if node != ast
-    end
+      if \
+        args.length == 1 and method == :+
+      then
+        node = collapse_strings(ast)
+        return parse node if node != ast
+      end
+
+      # :irange support
+      # - currently only .to_a
+      if \
+        receiver and
+        receiver.type == :begin and
+        [:irange, :erange].include? receiver.children.first.type
+      then
+        unless method == :to_a
+          raise Error.new("#{receiver.children.first.type} can only be converted to array currently", receiver.children.first)
+        else
+          return range_to_array(receiver.children.first)
+        end
+      end
 
       # strip '!' and '?' decorations
       method = method.to_s[0..-2] if method =~ /\w[!?]$/
@@ -29,6 +43,7 @@ module Ruby2JS
       # three ways to define anonymous functions
       if method == :new and receiver and receiver.children == [nil, :Proc]
         return parse args.first, @state
+
       elsif not receiver and [:lambda, :proc].include? method
         if method == :lambda
           return parse s(args.first.type, *args.first.children[0..-2],
@@ -39,7 +54,7 @@ module Ruby2JS
       end
 
       # call anonymous function
-      if [:call, :[]].include? method and receiver and receiver.type == :block 
+      if [:call, :[]].include? method and receiver and receiver.type == :block
         t2,m2,*args2 = receiver.children.first.children
         if not t2 and [:lambda, :proc].include? m2 and args2.length == 0
           (es2015 || @state == :statement ? group(receiver) : parse(receiver))
@@ -72,7 +87,7 @@ module Ruby2JS
               # async proc {|x| ... }
               return parse block.updated(:async, [nil, *block.children[1..-1]])
 
-            elsif
+            elsif \
               block.children[0].children[1] == :new and
               block.children[0].children[0] == s(:const, nil, :Proc)
             then
@@ -97,7 +112,7 @@ module Ruby2JS
 
       op_index = operator_index method
       if op_index != -1
-        target = args.first 
+        target = args.first
       end
 
       # resolve anonymous receivers against rbstack
@@ -109,7 +124,7 @@ module Ruby2JS
         group_receiver ||= GROUP_OPERATORS.include? receiver.type
         group_receiver = false if receiver.children[1] == :[]
         if receiver.type == :int and !OPERATORS.flatten.include?(method)
-          group_receiver = true 
+          group_receiver = true
         end
         if not receiver.is_method? and receiver.children.last == :new
           group_receiver = true 
@@ -117,7 +132,7 @@ module Ruby2JS
       end
 
       if target
-        group_target = target.type == :send && 
+        group_target = target.type == :send &&
           op_index < operator_index( target.children[1] )
         group_target ||= GROUP_OPERATORS.include? target.type
       end
@@ -127,7 +142,7 @@ module Ruby2JS
 
       elsif method == :[]
         (group_receiver ? group(receiver) : parse(receiver))
-        if
+        if \
           args.length == 1 and [:str, :sym].include? args.first.type and
           args.first.children.first.to_s =~ /^[a-zA-Z]\w*$/
         then
@@ -138,7 +153,7 @@ module Ruby2JS
 
       elsif method == :[]=
         parse receiver
-        if
+        if \
           args.length == 2 and [:str, :sym].include? args.first.type and
           args.first.children.first.to_s =~ /^[a-zA-Z]\w*$/
         then
@@ -156,7 +171,7 @@ module Ruby2JS
         put ')'
 
       elsif [:-@, :+@, :~, '~'].include? method
-        if 
+        if \
           receiver.type == :send and
           receiver.children[1] == :+@ and
           Parser::AST::Node === receiver.children[0] and
@@ -182,7 +197,13 @@ module Ruby2JS
 
       elsif OPERATORS.flatten.include?(method) and not LOGICAL.include?(method)
         (group_receiver ? group(receiver) : parse(receiver))
-        put " #{ method } "
+
+        if @comparison == :identity and [:==, :!=].include? method
+          put " #{ method }= "
+        else
+          put " #{ method } "
+        end
+
         (group_target ? group(target) : parse(target))
 
       elsif method =~ /=$/
@@ -235,7 +256,7 @@ module Ruby2JS
         elsif args.length == 1 and args.first.type == :const
           # accommodation for JavaScript like new syntax w/o argument list
           parse s(:attr, args.first, :new), @state
-        elsif 
+        elsif \
           args.length == 2 and [:send, :const].include? args.first.type and
           args.last.type == :def and args.last.children.first == nil
         then
@@ -269,7 +290,7 @@ module Ruby2JS
             parse ast.updated(:lvasgn, [method]), @state
           end
         elsif args.any? {|arg| arg.type == :splat} and not es2015
-          parse s(:send, s(:attr, receiver, method), :apply, 
+          parse s(:send, s(:attr, receiver, method), :apply,
             (receiver || s(:nil)), s(:array, *args))
         else
           (group_receiver ? group(receiver) : parse(receiver))
@@ -285,27 +306,46 @@ module Ruby2JS
     end
 
     handle :csend do |receiver, method, *args|
-      node = @ast
+      if es2020
 
-      # collect up chain of conditional sends
-      stack = []
-      while node.children.first.type == :csend
-        stack << node
-        node = node.children.first
-      end
+        # optional chaining
+        parse receiver
+        put "?."
+        if method == :[]
+          put '['
+          args.each {|arg| parse arg}
+          put ']'
+        else
+          put method.to_s
+          put '(' if @ast.is_method?
+          args.each {|arg| parse arg}
+          put ')' if @ast.is_method?
+        end
 
-      # conditionally evaluate most nested expression
-      expr = node.updated(:send)
-      result = s(:and, node.children.first, expr)
+      else
 
-      # build up chain of conditional evaluations
-      until stack.empty?
-        node = stack.pop
-        expr = node.updated(:send, [expr, *node.children[1..-1]])
-        result = s(:and, result, expr)
-      end
+        node = @ast
+
+        # collect up chain of conditional sends
+        stack = []
+        while node.children.first.type == :csend
+          stack << node
+          node = node.children.first
+        end
 
-      parse result
+        # conditionally evaluate most nested expression
+        expr = node.updated(:send)
+        result = s(:and, node.children.first, expr)
+
+        # build up chain of conditional evaluations
+        until stack.empty?
+          node = stack.pop
+          expr = node.updated(:send, [expr, *node.children[1..-1]])
+          result = s(:and, result, expr)
+        end
+
+        parse result
+      end
     end
 
     handle :splat do |expr|
@@ -313,47 +353,98 @@ module Ruby2JS
        parse expr
     end
 
-  # do string concatenation when possible
-  def collapse_strings(node)
-    left = node.children[0]
-    return node unless left
-    right = node.children[2]
-
-    # recursively evaluate left hand side
-    if 
-      left.type == :send and left.children.length == 3 and 
-      left.children[1] == :+
-    then
-      left = collapse_strings(left)
-    end
+    # do string concatenation when possible
+    def collapse_strings(node)
+      left = node.children[0]
+      return node unless left
+      right = node.children[2]
+
+      # recursively evaluate left hand side
+      if \
+        left.type == :send and left.children.length == 3 and
+        left.children[1] == :+
+      then
+        left = collapse_strings(left)
+      end
 
-    # recursively evaluate right hand side
-    if 
-      right.type == :send and right.children.length == 3 and 
-      right.children[1] == :+
-    then
-      right = collapse_strings(right)
-    end
+      # recursively evaluate right hand side
+      if \
+        right.type == :send and right.children.length == 3 and
+        right.children[1] == :+
+      then
+        right = collapse_strings(right)
+      end
 
-    # if left and right are both strings, perform concatenation
-    if [:dstr, :str].include? left.type and [:dstr, :str].include? right.type
-      if left.type == :str and right.type == :str
-        return left.updated nil, 
-          [left.children.first + right.children.first]
+      # if left and right are both strings, perform concatenation
+      if [:dstr, :str].include? left.type and [:dstr, :str].include? right.type
+        if left.type == :str and right.type == :str
+          return left.updated nil,
+            [left.children.first + right.children.first]
+        else
+          left = s(:dstr, left) if left.type == :str
+          right = s(:dstr, right) if right.type == :str
+          return left.updated(nil, left.children + right.children)
+        end
+      end
+
+      # if left and right are unchanged, return original node; otherwise
+      # return node modified to include new left and/or right hand sides.
+      if left == node.children[0] and right == node.children[2]
+        return node
       else
-        left = s(:dstr, left) if left.type == :str
-        right = s(:dstr, right) if right.type == :str
-        return left.updated(nil, left.children + right.children)
+        return node.updated(nil, [left, :+, right])
       end
     end
 
-    # if left and right are unchanged, return original node; otherwise
-    # return node modified to include new left and/or right hand sides.
-    if left == node.children[0] and right == node.children[2]
-      return node
-    else
-      return node.updated(nil, [left, :+, right]) 
+    def range_to_array(node)
+      start, finish = node.children
+      if start.type == :int and start.children.first == 0
+        # Ranges which start from 0 can be achieved with more simpler code
+        if finish.type == :int
+          # output cleaner code if we know the value already
+          length = finish.children.first + (node.type == :irange ? 1 : 0)
+        else
+          # If this is variable we need to fix indexing by 1 in js
+          length = "#{finish.children.last}" + (node.type == :irange ? "+1" : "")
+        end
+
+        if es2015
+          return put "[...Array(#{length}).keys()]"
+        else
+          return put "Array.apply(null, {length: #{length}}).map(Function.call, Number)"
+        end
+      else
+        # Use .compact because the first argument is nil with variables
+        # This way the first value is always set
+        start_value = start.children.compact.first
+        finish_value = finish.children.compact.first
+        if start.type == :int and finish.type == :int
+          length = finish_value - start_value + (node.type == :irange ? 1 : 0)
+        else
+          length = "(#{finish_value}-#{start_value}" + (node.type == :irange ? "+1" : "") + ")"
+        end
+
+        # Avoid of using same variables in the map as used in the irange or elsewhere in this code
+        # Ruby2js only allows dollar sign in beginning of variable so i$ is safe
+        if @vars.include? :idx or start_value == :idx or finish_value == :idx
+          index_var = 'i$'
+        else
+          index_var = 'idx'
+        end
+
+        if es2015
+          # Use _ because it's normal convention in JS for variable which is not used at all
+          if @vars.include? :_ or start_value == :_ or finish_value == :_
+            blank = '_$'
+          else
+            blank = '_'
+          end
+
+          return put "Array.from({length: #{length}}, (#{blank}, #{index_var}) => #{index_var}+#{start_value})"
+        else
+          return put "Array.apply(null, {length: #{length}}).map(Function.call, Number).map(function (#{index_var}) { return #{index_var}+#{start_value} })"
+        end
+      end
     end
   end
-  end
 end

data/lib/ruby2js/converter/super.rb

@@ -6,27 +6,33 @@ module Ruby2JS
     # (super ...)
 
     handle :super, :zsuper do |*args|
-      unless @instance_method and @class_parent
+      method = @instance_method || @class_method
+
+      unless method and @class_parent
         raise Error.new("super outside of a method", @ast)
       end
 
       # what to pass
       if @ast.type == :zsuper
-        if @instance_method.type == :method
-          args = @instance_method.children[2].children[1].children
-        elsif @instance_method.type == :prop
+        if method.type == :method
+          args = method.children[2].children[1].children
+        elsif method.type == :prop
           args = nil
         else
-          args = @instance_method.children[1].children
+          args = method.children[1].children
         end
       end
 
       if es2015
-        if @instance_method.children[0] == :constructor
+        if @class_method
+          parse @class_parent
+          put '.'
+          put method.children[0]
+        elsif method.children[0] == :constructor
           put 'super'
         else
           put 'super.'
-          put @instance_method.children[0]
+          put method.children[0]
         end
 
         put '('
@@ -36,8 +42,8 @@ module Ruby2JS
         parse @class_parent
 
         # what to call
-        if @instance_method.type != :constructor
-          puts  ".prototype.#{ @instance_method.children[1].to_s.chomp('=') }"
+        if method.type != :constructor
+          puts  ".prototype.#{ method.children[1].to_s.chomp('=') }"
         end
 
         if args