ruby2js 3.1.1 → 3.3.2

data/lib/ruby2js/converter/xnode.rb

@@ -0,0 +1,89 @@
+module Ruby2JS
+  class Converter
+
+    # (xnode str hash) 
+
+    # NOTE: xnode is a synthetic 
+
+    handle :xnode do |nodename, *args|
+      attrs = {}
+      children = []
+
+      args.each do |arg|
+        if arg.type == :hash
+          arg.children.each do |pair|
+            name = pair.children[0].children[0]
+
+            if defined? Ruby2JS::Filter::React
+              name = :className if name == :class
+              name = :htmlFor if name == :for
+            end
+
+            if [:class, :className].include? name and attrs[name]
+              if attrs[name].type == :str and pair.children[1].type == :str
+                attrs[name] = s(:str, pair.children[1].children[0] + ' ' +
+                  attrs[name].children[0])
+              else
+                attrs[name] = s(:send, s(:send, attrs[name], :+, 
+                  s(:str, ' ')), :+, pair.children[1])
+              end
+            else
+              attrs[name] = pair.children[1]
+            end
+          end
+        elsif arg.type == :begin
+          children += arg.children
+        else
+          children << arg
+        end
+      end
+
+      put '<'
+      put nodename
+
+      attrs.each do |name, value|
+        put ' '
+        put name
+        put '='
+        if value.type == :str
+          parse value
+        else
+          put '{'
+          parse value
+          put '}'
+        end
+      end
+
+      if children.empty?
+        put '/>'
+      else
+        put '>'
+        put @nl unless children.length == 1 and children.first.type != :xnode
+
+        children.each_with_index do |child, index|
+          put @nl unless index == 0
+          if child.type == :str
+            put child.children.first
+          elsif child.type == :xnode
+            parse child
+          else
+            begin
+              jsx, @jsx = @jsx, true
+              put '{'
+              parse child
+              put '}'
+            ensure
+              @jsx = jsx
+            end
+          end
+        end
+
+        put @nl unless children.length == 1 and children.first.type != :xnode
+
+        put '</'
+        put nodename
+        put ">"
+      end
+    end
+  end
+end

data/lib/ruby2js/es2021.rb

@@ -0,0 +1,5 @@
+require 'ruby2js'
+
+if Ruby2JS.eslevel_default < 2021
+  Ruby2JS.eslevel_default = 2021
+end

data/lib/ruby2js/es2021/strict.rb

@@ -0,0 +1,3 @@
+require 'ruby2js/es2021'
+
+Ruby2JS.strict_default = true

data/lib/ruby2js/filter/cjs.rb

@@ -24,7 +24,7 @@ module Ruby2JS
             *assign.children[1..-1]
           ])
 
-        elsif 
+        elsif \
           node.children[2].type == :send and
           node.children[2].children[0..1] == [nil, :async] and
           node.children[2].children[2].type == :def
@@ -38,7 +38,7 @@ module Ruby2JS
               *process_all(fn.children[1..-1])))
           ])
 
-        elsif 
+        elsif \
           node.children[2].type == :send and
           node.children[2].children[0..1] == [nil, :default]
         then

data/lib/ruby2js/filter/esm.rb

@@ -0,0 +1,72 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module ESM
+      include SEXP
+
+      def initialize(*args)
+        @esm_include = nil
+        super
+      end
+
+      def process(node)
+        return super if @esm_include
+        @esm_include = Set.new
+        @esm_exclude = Set.new
+        @esm_export = nil
+        result = super
+
+        esm_walk(result)
+
+        inventory = (@esm_include - @esm_exclude).to_a.sort
+
+        if inventory.empty? and not @esm_export
+          result
+        else
+          list = inventory.map do |name|
+             if name == "React" and defined? Ruby2JS::Filter::React
+               s(:import, "#{name.downcase}", s(:const, nil, name))
+             elsif not %w(JSON Object).include? name
+               s(:import, "./#{name.downcase}.js", s(:const, nil, name))
+             end
+          end
+
+          list.push result
+
+          if @esm_export
+            list.push s(:export, :default, s(:const, nil, @esm_export))
+          end
+
+          s(:begin, *list.compact)
+        end
+      end
+
+      # gather constants
+      def esm_walk(node)
+        # extract ivars and cvars
+        if node.type == :const and node.children.first == nil
+          @esm_include << node.children.last.to_s
+        elsif node.type == :xnode
+          name = node.children.first
+          @esm_include << name unless name.empty? or name =~ /^[a-z]/
+        elsif node.type == :casgn and node.children.first == nil
+          @esm_exclude << node.children[1].to_s
+        elsif node.type == :class and node.children.first.type == :const
+          if node.children.first.children.first == nil
+            name = node.children.first.children.last.to_s
+            @esm_exclude << name
+            @esm_export ||= name
+          end
+        end
+
+        # recurse
+        node.children.each do |child|
+          esm_walk(child) if Parser::AST::Node === child
+        end
+      end
+    end
+
+    DEFAULTS.push ESM
+  end
+end

data/lib/ruby2js/filter/functions.rb

@@ -1,4 +1,5 @@
 require 'ruby2js'
+require 'regexp_parser'
 
 module Ruby2JS
   module Filter
@@ -15,6 +16,11 @@ module Ruby2JS
         gvar: :gvasgn
       }
 
+      def initialize(*args)
+        @jsx = false
+        super
+      end
+
       def on_send(node)
         target, method, *args = node.children
         return super if excluded?(method)
@@ -35,6 +41,78 @@ module Ruby2JS
         elsif method == :keys and args.length == 0 and node.is_method?
           process S(:send, s(:const, nil, :Object), :keys, target)
 
+        elsif method == :[]= and args.length == 3 and
+          args[0].type == :regexp and args[1].type == :int
+          index = args[1].children.first
+
+          parts = Regexp::Parser.parse(args[0].children.first.children.first)
+          split = parts.index do |part|
+            part.type == :group and part.number == index
+          end
+
+          return super unless split
+
+          rewritten = parts[split].to_s
+
+          dstr = [args.last]
+          if rewritten == '()'
+            index -= 1
+            rewritten = ''
+          end
+
+          parts = parts.to_a
+
+          pre = ''
+          if parts.first.type == :anchor
+            pre = parts.shift.to_s
+            split -= 1
+          end
+
+          if split > 0
+            if split == 1 and parts.first.type == :group
+              rewritten = parts.first.to_s + rewritten
+            else
+              rewritten = '(' + parts[0 .. split - 1].join + ')' + rewritten
+              index += 1
+            end
+            dstr.unshift s(:send, s(:lvar, :match), :[], s(:int, 0))
+          end
+
+
+          post = ''
+          if parts.last.type == :anchor
+            post = parts.pop.to_s
+          end
+
+          if split + 1 < parts.length
+            if split  + 2 == parts.length and parts.last.type == :group
+              rewritten += parts.last.to_s
+            else
+              rewritten += '(' + parts[split + 1 .. -1].join + ')'
+            end
+            dstr << s(:send, s(:lvar, :match), :[], s(:int, index))
+          end
+
+          rewritten = pre + rewritten + post
+
+          regex = process s(:regexp, s(:str, rewritten), args[0].children.last)
+          block = s(:block,
+            s(:send, target, :replace, regex),
+            s(:args, s(:arg, :match)),
+            process(s(:dstr, *dstr)))
+
+          if VAR_TO_ASSIGN.keys.include? target.type
+            S(VAR_TO_ASSIGN[target.type], target.children.first, block)
+          elsif target.type == :send
+            if target.children[0] == nil
+              S(:lvasgn, target.children[1], block)
+            else
+              S(:send, target.children[0], :"#{target.children[1]}=", block)
+            end
+          else
+            super
+          end
+
         elsif method == :merge
           args.unshift target
 
@@ -50,9 +128,15 @@ module Ruby2JS
 
             s(:send, s(:block, s(:send, nil, :lambda), s(:args),
               s(:begin, *copy, *args.map {|modname|
-              s(:for, s(:lvasgn, :$_), modname,
-              s(:send, s(:gvar, :$$), :[]=,
-              s(:lvar, :$_), s(:send, modname, :[], s(:lvar, :$_))))
+              if modname.type == :hash
+                s(:begin, *modname.children.map {|pair|
+                    s(:send, s(:gvar, :$$), :[]=, *pair.children)
+                  })
+              else
+                s(:for, s(:lvasgn, :$_), modname,
+                s(:send, s(:gvar, :$$), :[]=,
+                s(:lvar, :$_), s(:send, modname, :[], s(:lvar, :$_))))
+              end
               }, s(:return, s(:gvar, :$$)))), :[])
           end
 
@@ -72,9 +156,15 @@ module Ruby2JS
 
             s(:send, s(:block, s(:send, nil, :lambda), s(:args),
               s(:begin, *copy, *args.map {|modname|
-              s(:for, s(:lvasgn, :$_), modname,
-              s(:send, target, :[]=,
-              s(:lvar, :$_), s(:send, modname, :[], s(:lvar, :$_))))
+              if modname.type == :hash
+                s(:begin, *modname.children.map {|pair|
+                    s(:send, target, :[]=, *pair.children)
+                  })
+              else
+                s(:for, s(:lvasgn, :$_), modname,
+                s(:send, target, :[]=,
+                s(:lvar, :$_), s(:send, modname, :[], s(:lvar, :$_))))
+              end
               }, s(:return, target))), :[])
           end
 
@@ -134,23 +224,33 @@ module Ruby2JS
               [s(:str, Regexp.escape(arg.children.first)), s(:regopt)])
           end
 
-          pattern = arg.children.first.children.first
-          pattern = pattern.gsub(/\\./, '').gsub(/\[.*\]/, '')
-
           if arg.type == :regexp
+            pattern = arg.children.first.children.first
+            pattern = pattern.gsub(/\\./, '').gsub(/\[.*\]/, '')
+
             gpattern = arg.updated(:regexp, [*arg.children[0...-1],
               s(:regopt, :g, *arg.children.last)])
           else
-            super
+            gpattern = s(:send, s(:const, nil, :RegExp), :new, arg, s(:str, 'g'))
           end
 
-          if pattern.include? '('
-            s(:block, s(:send,
-              s(:send, process(target), :match, gpattern), :map),
-              s(:args, s(:arg, :s)),
-              s(:return, s(:send, s(:send, s(:lvar, :s), :match, arg),
-              :slice, s(:int, 1))))
+          if arg.type != :regexp or pattern.include? '('
+            if es2020
+              # Array.from(str.matchAll(/.../g), s => s.slice(1))
+              s(:send, s(:const, nil, :Array), :from,
+                s(:send, process(target), :matchAll, gpattern),
+                s(:block, s(:send, nil, :proc), s(:args, s(:arg, :s)),
+                  s(:send, s(:lvar, :s), :slice, s(:int, 1))))
+            else
+              # str.match(/.../g).map(s => s.match(/.../).slice(1))
+              s(:block, s(:send,
+                s(:send, process(target), :match, gpattern), :map),
+                s(:args, s(:arg, :s)),
+                s(:return, s(:send, s(:send, s(:lvar, :s), :match, arg),
+                :slice, s(:int, 1))))
+            end
           else
+            # str.match(/.../g)
             S(:send, process(target), :match, gpattern)
           end
 
@@ -278,6 +378,9 @@ module Ruby2JS
           end
 
 
+        elsif method == :[] and target == s(:const, nil, :Hash)
+          s(:send, s(:const, nil, :Object), :fromEntries, *process_all(args))
+
         elsif method == :[]
           # resolve negative literal indexes
           i = proc do |index|
@@ -295,9 +398,15 @@ module Ruby2JS
             super
 
           elsif index.type == :regexp
-            process S(:send,
-              s(:or, S(:send, process(target), :match, index), s(:array)),
-              :[], args[1] || s(:int, 0))
+            if es2020
+              process S(:csend,
+                S(:send, process(target), :match, index),
+                :[], args[1] || s(:int, 0))
+            else
+              process S(:send,
+                s(:or, S(:send, process(target), :match, index), s(:array)),
+                :[], args[1] || s(:int, 0))
+            end
 
           elsif node.children.length != 3
             super
@@ -307,7 +416,9 @@ module Ruby2JS
 
           elsif index.type == :erange
             start, finish = index.children
-            if finish.type == :int
+            if not finish
+              process S(:send, target, :slice, start)
+            elsif finish.type == :int
               process S(:send, target, :slice, i.(start), finish)
             else
               process S(:send, target, :slice, i.(start), i.(finish))
@@ -315,7 +426,7 @@ module Ruby2JS
 
           elsif index.type == :irange
             start, finish = index.children
-            if finish.type == :int
+            if finish and finish.type == :int
               final = S(:int, finish.children.first+1)
             else
               final = S(:send, finish, :+, s(:int, 1))
@@ -323,7 +434,7 @@ module Ruby2JS
 
             # No need for the last argument if it's -1
             # This means take all to the end of array
-            if finish.children.first == -1
+            if not finish or finish.children.first == -1
               process S(:send, target, :slice, start)
             else
               process S(:send, target, :slice, start, final)
@@ -395,15 +506,28 @@ module Ruby2JS
           process node.updated(nil, [s(:const, nil, :Object), :fromEntries,
             target])
 
-        elsif es2019 and method==:rstrip
-          process node.updated(nil, [target, :trimStart, *args])
+        elsif method==:rstrip
+          if es2019
+            process node.updated(nil, [target, :trimEnd, *args])
+          else
+            node.updated(nil, [process(target), :replace,
+              s(:regexp, s(:str, '\s+\z') , s(:regopt)), s(:str, '')])
+          end
 
-        elsif es2019 and method==:lstrip
-          process node.updated(nil, [target, :trimEnd, *args])
+        elsif method==:lstrip and args.length == 0
+          if es2019
+            process s(:send, target, :trimStart)
+          else
+            node.updated(nil, [process(target), :replace,
+              s(:regexp, s(:str, '\A\s+') , s(:regopt)), s(:str, '')])
+          end
 
         elsif method == :class and args.length==0 and not node.is_method?
           process node.updated(:attr, [target, :constructor])
 
+        elsif method == :new and target == s(:const, nil, :Exception)
+          process S(:send, s(:const, nil, :Error), :new, *args)
+
         else
           super
         end
@@ -498,7 +622,7 @@ module Ruby2JS
           call = call.updated(nil, [s(:begin, range), :step, s(:int, 1)])
           process node.updated(nil, [call, *node.children[1..-1]])
 
-        elsif
+        elsif \
           method == :each and call.children[0].type == :send and
           call.children[0].children[1] == :step
         then
@@ -510,7 +634,7 @@ module Ruby2JS
             :step, step])
           process node.updated(nil, [call, *node.children[1..-1]])
 
-        elsif
+        elsif \
           # (a..b).each {|v| ...}
           method == :each and
           call.children[0].type == :begin and
@@ -518,23 +642,34 @@ module Ruby2JS
           [:irange, :erange].include? call.children[0].children[0].type and
           node.children[1].children.length == 1
         then
-          s(:for, s(:lvasgn, node.children[1].children[0].children[0]),
+          process s(:for, s(:lvasgn, node.children[1].children[0].children[0]),
             call.children[0].children[0], node.children[2])
 
-        elsif
-          [:each, :each_value].include? method and
-          node.children[1].children.length == 1
+        elsif \
+          [:each, :each_value].include? method
         then
-          if es2015
-            process node.updated(:for_of,
-              [s(:lvasgn, node.children[1].children[0].children[0]),
-              node.children[0].children[0], node.children[2]])
+          if es2015 or @jsx
+            if node.children[1].children.length > 1
+              process node.updated(:for_of,
+                [s(:mlhs, *node.children[1].children.map {|child|
+                  s(:lvasgn, child.children[0])}),
+                node.children[0].children[0], node.children[2]])
+            elsif node.children[1].children[0].type == :mlhs
+              process node.updated(:for_of,
+                [s(:mlhs, *node.children[1].children[0].children.map {|child|
+                  s(:lvasgn, child.children[0])}),
+                node.children[0].children[0], node.children[2]])
+            else
+              process node.updated(:for_of,
+                [s(:lvasgn, node.children[1].children[0].children[0]),
+                node.children[0].children[0], node.children[2]])
+            end
           else
             process node.updated(nil, [s(:send, call.children[0],
               :forEach), *node.children[1..2]])
           end
 
-        elsif
+        elsif \
           method == :each_key and
           [:each, :each_key].include? method and
           node.children[1].children.length == 1
@@ -548,10 +683,25 @@ module Ruby2JS
             s(:block, s(:send, nil, :lambda), *node.children[1..2]),
             *call.children[2..-1]])
 
-        elsif es2017 and method == :each_pair
-          process node.updated(nil, [s(:send, s(:send, s(:const, nil, :Object),
-            :entries, call.children[0]), :forEach), s(:args, s(:mlhs,
-            *node.children[1].children)), node.children[2]])
+        elsif method == :each_pair and node.children[1].children.length == 2
+          if es2017
+            # Object.entries(a).forEach(([key, value]) => {})
+            process node.updated(nil, [s(:send, s(:send,
+            s(:const, nil, :Object), :entries, call.children[0]), :each),
+            node.children[1], node.children[2]])
+          else
+            # for (key in a). {var value = a[key]; ...}
+            process node.updated(:for, [s(:lvasgn,
+              node.children[1].children[0].children[0]), call.children[0],
+              s(:begin, s(:lvasgn, node.children[1].children[1].children[0],
+              s(:send, call.children[0], :[], 
+              s(:lvar, node.children[1].children[0].children[0]))),
+              node.children[2])])
+          end
+
+        elsif method == :scan and call.children.length == 3
+          process call.updated(nil, [*call.children, s(:block,
+            s(:send, nil, :proc), *node.children[1..-1])])
 
         else
           super