ruby2js 3.5.0 → 3.6.1

data/lib/ruby2js/filter/esm.rb

@@ -1,13 +1,68 @@
 require 'ruby2js'
 
+Ruby2JS.module_default = :esm
+
 module Ruby2JS
   module Filter
     module ESM
       include SEXP
 
-      def initialize(*args)
+      def options=(options)
+        super
+        @esm_autoexports = options[:autoexports] && !@disable_autoexports
+        @esm_autoimports = options[:autoimports]
+        @esm_explicit_tokens = Set.new
+      end
+
+      def process(node)
+        return super unless @esm_autoexports
+        @esm_autoexports = false
+
+        list = [node]
+        while list.length == 1 and list.first.type == :begin
+          list = list.first.children.dup
+        end
+
+        list.map! do |child|
+          replacement = child
+
+          if [:module, :class].include? child.type and
+            child.children.first.type == :const and
+            child.children.first.children.first == nil \
+          then
+            replacement = s(:export, child)
+          elsif child.type == :casgn and child.children.first == nil
+            replacement = s(:export, child)
+          elsif child.type == :def
+            replacement = s(:export, child)
+          end
+
+          if replacement != child and @comments[child]
+            @comments[replacement] = @comments[child]
+          end
+
+          replacement
+        end
+
+        process s(:begin, *list)
+      end
+
+      def on_class(node)
+        @esm_explicit_tokens << node.children.first.children.last
+
+        super
+      end
+
+      def on_def(node)
+        @esm_explicit_tokens << node.children.first
+
+        super
+      end
+
+      def on_lvasgn(node)
+        @esm_explicit_tokens << node.children.first
+
         super
-        @esm = true # signal for other filters
       end
 
       def on_send(node)
@@ -36,6 +91,8 @@ module Ruby2JS
             args[0].children[2].children[2].type == :str
             # import name from "file.js"
             #  => import name from "file.js"
+            @esm_explicit_tokens << args[0].children[1]
+
             s(:import,
               [args[0].children[2].children[2].children[0]],
               process(s(:attr, nil, args[0].children[1])))
@@ -49,17 +106,52 @@ module Ruby2JS
             #   => import Stuff as * from "file.js"
             # import [ Some, Stuff ], from: "file.js"
             #   => import { Some, Stuff } from "file.js"
-            imports = (args[0].type == :const || args[0].type == :send) ?
-              process(args[0]) : 
+            imports = if args[0].type == :const || args[0].type == :send
+              @esm_explicit_tokens << args[0].children.last
+              process(args[0])
+            else
+              args[0].children.each {|i| @esm_explicit_tokens << i.children.last}
               process_all(args[0].children)
+            end
+
             s(:import, args[1].children, imports) unless args[1].nil?
           end
         elsif method == :export          
           s(:export, *process_all(args))
+        elsif target.nil? and found_import = find_autoimport(method)
+          prepend_list << s(:import, found_import[0], found_import[1])
+          super
         else
           super
         end
       end
+
+      def on_const(node)
+        if node.children.first == nil and found_import = find_autoimport(node.children.last)
+          prepend_list << s(:import, found_import[0], found_import[1])
+        end
+
+        super
+      end
+
+      def on_export(node)
+        s(:export, *process_all(node.children))
+      end
+    end
+
+    private
+
+    def find_autoimport(token)
+      return nil if @esm_autoimports.nil?
+      return nil if @esm_explicit_tokens.include?(token)
+
+      token = camelCase(token) if respond_to?(:camelCase)
+
+      if @esm_autoimports[token]
+        [@esm_autoimports[token], s(:const, nil, token)]
+      elsif found_key = @esm_autoimports.keys.find {|key| key.is_a?(Array) && key.include?(token)}
+        [@esm_autoimports[found_key], found_key.map {|key| s(:const, nil, key)}]
+      end
     end
 
     DEFAULTS.push ESM

data/lib/ruby2js/filter/functions.rb

@@ -26,9 +26,15 @@ module Ruby2JS
         return super if excluded?(method)
 
         if [:max, :min].include? method and args.length == 0
-          return super unless node.is_method?
-          process S(:send, s(:const, nil, :Math), node.children[1],
-            s(:splat, target))
+          if target.type == :array
+            process S(:send, s(:const, nil, :Math), node.children[1],
+              *target.children)
+          elsif node.is_method?
+            process S(:send, s(:const, nil, :Math), node.children[1],
+              s(:splat, target))
+          else
+            return super
+          end
 
         elsif method == :call and target and target.type == :ivar
           process S(:send, s(:self), "_#{target.children.first.to_s[1..-1]}",
@@ -531,6 +537,20 @@ module Ruby2JS
         elsif method == :block_given? and target == nil and args.length == 0
           process process s(:lvar, "_implicitBlockYield")
 
+        elsif method == :abs and args.length == 0
+          process S(:send, s(:const, nil, :Math), :abs, target)
+
+        elsif method == :ceil and args.length == 0
+          process S(:send, s(:const, nil, :Math), :ceil, target)
+
+        elsif method == :floor and args.length == 0
+          process S(:send, s(:const, nil, :Math), :floor, target)
+
+        elsif method == :sum and args.length == 0
+          process S(:send, target, :reduce, s(:block, s(:send, nil, :proc),
+            s(:args, s(:arg, :a), s(:arg, :b)),
+            s(:send, s(:lvar, :a), :+, s(:lvar, :b))), s(:int, 0))
+
         else
           super
         end

data/lib/ruby2js/filter/node.rb

@@ -1,44 +1,25 @@
 require 'ruby2js'
 require 'set'
 
+Ruby2JS.module_default ||= :cjs
+
 module Ruby2JS
   module Filter
     module Node
       include SEXP
       extend SEXP
 
-      CJS_SETUP = {
-        child_process: s(:casgn, nil, :child_process, 
-          s(:send, nil, :require, s(:str, "child_process"))),
-        fs: s(:casgn, nil, :fs, s(:send, nil, :require, s(:str, "fs"))),
-        ARGV: s(:lvasgn, :ARGV, s(:send, s(:attr, 
-          s(:attr, nil, :process), :argv), :slice, s(:int, 2)))
-      }
-
-      ESM_SETUP = {
-        child_process: s(:import, ['child_process'],
-          s(:attr, nil, :child_process)),
-        fs: s(:import, ['fs'], s(:attr, nil, :fs)),
-        ARGV: CJS_SETUP[:ARGV]
-      }
-
-      def initialize(*args)
-        @node_setup = nil
-        super
-      end
+      IMPORT_CHILD_PROCESS = s(:import, ['child_process'],
+          s(:attr, nil, :child_process))
 
-      def process(node)
-        return super if @node_setup
-        @node_setup = Set.new
-        result = super
+      IMPORT_FS = s(:import, ['fs'], s(:attr, nil, :fs))
 
-        if @node_setup.empty?
-          result
-        else
-          setup = @esm ? ESM_SETUP : CJS_SETUP;
-          s(:begin, *@node_setup.to_a.map {|token| setup[token]}, result)
-        end
-      end
+      IMPORT_OS = s(:import, ['os'], s(:attr, nil, :os))
+
+      IMPORT_PATH = s(:import, ['path'], s(:attr, nil, :path))
+
+      SETUP_ARGV = s(:lvasgn, :ARGV, s(:send, s(:attr, 
+          s(:attr, nil, :process), :argv), :slice, s(:int, 2)))
 
       def on_send(node)
         target, method, *args = node.children
@@ -51,14 +32,14 @@ module Ruby2JS
             s(:send, s(:attr, nil, :process), :exit, *process_all(args));
 
           elsif method == :system
-            @node_setup << :child_process
+            prepend_list << IMPORT_CHILD_PROCESS
 
             if args.length == 1
-              s(:send, s(:attr, nil, :child_process), :execSync,
+              S(:send, s(:attr, nil, :child_process), :execSync,
               process(args.first),
               s(:hash, s(:pair, s(:sym, :stdio), s(:str, 'inherit'))))
             else
-              s(:send, s(:attr, nil, :child_process), :execFileSync,
+              S(:send, s(:attr, nil, :child_process), :execFileSync,
               process(args.first), s(:array, *process_all(args[1..-1])),
               s(:hash, s(:pair, s(:sym, :stdio), s(:str, 'inherit'))))
             end
@@ -79,38 +60,38 @@ module Ruby2JS
           target.type == :const and target.children.first == nil
         then
           if method == :read and args.length == 1
-            @node_setup << :fs
-            s(:send, s(:attr, nil, :fs), :readFileSync, *process_all(args),
+            prepend_list << IMPORT_FS
+            S(:send, s(:attr, nil, :fs), :readFileSync, *process_all(args),
               s(:str, 'utf8'))
 
           elsif method == :write and args.length == 2
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             S(:send, s(:attr, nil, :fs), :writeFileSync, *process_all(args))
 
           elsif target.children.last == :IO
             super
 
           elsif [:exist?, :exists?].include? method and args.length == 1
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             S(:send, s(:attr, nil, :fs), :existsSync, process(args.first))
 
           elsif method == :readlink and args.length == 1
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             S(:send, s(:attr, nil, :fs), :readlinkSync, process(args.first))
 
           elsif method == :realpath and args.length == 1
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             S(:send, s(:attr, nil, :fs), :realpathSync, process(args.first))
 
           elsif method == :rename and args.length == 2
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             S(:send, s(:attr, nil, :fs), :renameSync, *process_all(args))
 
           elsif \
             [:chmod, :lchmod].include? method and 
             args.length > 1 and args.first.type == :int
           then
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
 
             S(:begin, *args[1..-1].map{|file|
               S(:send, s(:attr, nil, :fs), method.to_s + 'Sync', process(file),
@@ -121,7 +102,7 @@ module Ruby2JS
             [:chown, :lchown].include? method and args.length > 2 and 
             args[0].type == :int and args[1].type == :int
           then
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
 
             S(:begin, *args[2..-1].map{|file|
               s(:send, s(:attr, nil, :fs), method.to_s + 'Sync', process(file),
@@ -129,28 +110,51 @@ module Ruby2JS
             })
 
           elsif [:ln, :link].include? method and args.length == 2
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             s(:send, s(:attr, nil, :fs), :linkSync, *process_all(args))
             
           elsif method == :symlink and args.length == 2
-            @node_setup << :fs
-            s(:send, s(:attr, nil, :fs), :symlinkSync, *process_all(args))
+            prepend_list << IMPORT_FS
+            S(:send, s(:attr, nil, :fs), :symlinkSync, *process_all(args))
             
           elsif method == :truncate and args.length == 2
-            @node_setup << :fs
-            s(:send, s(:attr, nil, :fs), :truncateSync, *process_all(args))
+            prepend_list << IMPORT_FS
+            S(:send, s(:attr, nil, :fs), :truncateSync, *process_all(args))
             
           elsif [:stat, :lstat].include? method and args.length == 1
-            @node_setup << :fs
-            s(:send, s(:attr, nil, :fs), method.to_s + 'Sync',
+            prepend_list << IMPORT_FS
+            S(:send, s(:attr, nil, :fs), method.to_s + 'Sync',
               process(args.first))
 
           elsif method == :unlink and args.length == 1
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             S(:begin, *args.map{|file|
               S(:send, s(:attr, nil, :fs), :unlinkSync, process(file))
             })
 
+          elsif target.children.last == :File
+            if method == :absolute_path
+              prepend_list << IMPORT_PATH
+              S(:send, s(:attr, nil, :path), :resolve,
+                *process_all(args.reverse))
+            elsif method == :absolute_path?
+              prepend_list << IMPORT_PATH
+              S(:send, s(:attr, nil, :path), :isAbsolute, *process_all(args))
+            elsif method == :basename
+              prepend_list << IMPORT_PATH
+              S(:send, s(:attr, nil, :path), :basename, *process_all(args))
+            elsif method == :dirname
+              prepend_list << IMPORT_PATH
+              S(:send, s(:attr, nil, :path), :dirname, *process_all(args))
+            elsif method == :extname
+              prepend_list << IMPORT_PATH
+              S(:send, s(:attr, nil, :path), :extname, *process_all(args))
+            elsif method == :join
+              prepend_list << IMPORT_PATH
+              S(:send, s(:attr, nil, :path), :join, *process_all(args))
+            else
+              super
+            end
           else
             super
           end
@@ -169,15 +173,15 @@ module Ruby2JS
           end
             
           if [:cp, :copy].include? method and args.length == 2
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             s(:send, s(:attr, nil, :fs), :copyFileSync, *process_all(args))
             
           elsif [:mv, :move].include? method and args.length == 2
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             S(:send, s(:attr, nil, :fs), :renameSync, *process_all(args))
 
           elsif method == :mkdir and args.length == 1
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             S(:begin, *list[args.last].map {|file|
               s(:send, s(:attr, nil, :fs), :mkdirSync, process(file))
             })
@@ -186,24 +190,24 @@ module Ruby2JS
             S(:send, s(:attr, nil, :process), :chdir, *process_all(args))
 
           elsif method == :pwd and args.length == 0
-            s(:send, s(:attr, nil, :process), :cwd)
+            S(:send!, s(:attr, nil, :process), :cwd)
 
           elsif method == :rmdir and args.length == 1
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             S(:begin, *list[args.last].map {|file|
               s(:send, s(:attr, nil, :fs), :rmdirSync, process(file))
             })
 
           elsif method == :ln and args.length == 2
-            @node_setup << :fs
-            s(:send, s(:attr, nil, :fs), :linkSync, *process_all(args))
+            prepend_list << IMPORT_FS
+            S(:send, s(:attr, nil, :fs), :linkSync, *process_all(args))
             
           elsif method == :ln_s and args.length == 2
-            @node_setup << :fs
-            s(:send, s(:attr, nil, :fs), :symlinkSync, *process_all(args))
+            prepend_list << IMPORT_FS
+            S(:send, s(:attr, nil, :fs), :symlinkSync, *process_all(args))
             
           elsif method == :rm and args.length == 1
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             S(:begin, *list[args.last].map {|file|
               s(:send, s(:attr, nil, :fs), :unlinkSync, process(file))
             })
@@ -211,7 +215,7 @@ module Ruby2JS
           elsif \
             method == :chmod and args.length == 2 and args.first.type == :int
           then
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
 
             S(:begin, *list[args.last].map {|file|
               S(:send, s(:attr, nil, :fs), method.to_s + 'Sync', process(file),
@@ -222,14 +226,14 @@ module Ruby2JS
             method == :chown and args.length == 3 and 
             args[0].type == :int and args[1].type == :int
           then
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
 
             S(:begin, *list[args.last].map {|file|
               s(:send, s(:attr, nil, :fs), method.to_s + 'Sync', process(file),
                 *process_all(args[0..1]))})
 
           elsif method == :touch
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
 
             S(:begin, *list[args.first].map {|file|
               S(:send, s(:attr, nil, :fs), :closeSync,
@@ -247,18 +251,18 @@ module Ruby2JS
           if method == :chdir and args.length == 1
             S(:send, s(:attr, nil, :process), :chdir, *process_all(args))
           elsif method == :pwd and args.length == 0
-            s(:send, s(:attr, nil, :process), :cwd)
+            S(:send!, s(:attr, nil, :process), :cwd)
           elsif method == :entries
-            @node_setup << :fs
-            s(:send, s(:attr, nil, :fs), :readdirSync, *process_all(args))
+            prepend_list << IMPORT_FS
+            S(:send, s(:attr, nil, :fs), :readdirSync, *process_all(args))
           elsif method == :mkdir and args.length == 1
-            @node_setup << :fs
-            s(:send, s(:attr, nil, :fs), :mkdirSync, process(args.first))
+            prepend_list << IMPORT_FS
+            S(:send, s(:attr, nil, :fs), :mkdirSync, process(args.first))
           elsif method == :rmdir and args.length == 1
-            @node_setup << :fs
-            s(:send, s(:attr, nil, :fs), :rmdirSync, process(args.first))
+            prepend_list << IMPORT_FS
+            S(:send, s(:attr, nil, :fs), :rmdirSync, process(args.first))
           elsif method == :mktmpdir and args.length <=1
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             if args.length == 0
               prefix = s(:str, 'd')
             elsif args.first.type == :array
@@ -267,7 +271,14 @@ module Ruby2JS
               prefix = args.first
             end
 
-            s(:send, s(:attr, nil, :fs), :mkdtempSync, process(prefix))
+            S(:send, s(:attr, nil, :fs), :mkdtempSync, process(prefix))
+          elsif method == :home and args.length == 0
+            prepend_list << IMPORT_OS
+            S(:send!, s(:attr, nil, :os), :homedir)
+          elsif method == :tmpdir and args.length == 0
+            prepend_list << IMPORT_OS
+            S(:send!, s(:attr, nil, :os), :tmpdir)
+
           else
             super
           end
@@ -298,7 +309,7 @@ module Ruby2JS
 
       def on_const(node)
         if node.children == [nil, :ARGV]
-          @node_setup << :ARGV
+          prepend_list << SETUP_ARGV
           super
         elsif node.children == [nil, :ENV]
           S(:attr, s(:attr, nil, :process), :env)
@@ -308,6 +319,16 @@ module Ruby2JS
           S(:attr, s(:attr, nil, :process), :stdout)
         elsif node.children == [nil, :STDERR]
           S(:attr, s(:attr, nil, :process), :stderr)
+        elsif node.children.first == s(:const, nil, :File)
+          if node.children.last == :SEPARATOR
+            prepend_list << IMPORT_PATH
+            S(:attr, s(:attr, nil, :path), :sep)
+          elsif node.children.last == :PATH_SEPARATOR
+            prepend_list << IMPORT_PATH
+            S(:attr, s(:attr, nil, :path), :delimiter)
+          else
+            super
+          end
         else
           super
         end
@@ -326,7 +347,7 @@ module Ruby2JS
       end
 
       def on_xstr(node)
-        @node_setup << :child_process
+        prepend_list << IMPORT_CHILD_PROCESS
 
         children = node.children.dup
         command = children.shift