ruby2js 3.4.0 → 3.6.0

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

data/lib/ruby2js/filter/nokogiri.rb

@@ -7,33 +7,7 @@ module Ruby2JS
       include SEXP
       extend SEXP
 
-      CJS_SETUP = {
-        jsdom: s(:casgn, nil, :JSDOM, 
-          s(:attr, s(:send, nil, :require, s(:str, "jsdom")), :JSDOM))
-      }
-
-      ESM_SETUP = {
-        jsdom: s(:import, ["jsdom"], [s(:attr, nil, :JSDOM)])
-      }
-
-      def initialize(*args)
-        @nokogiri_setup = nil
-        super
-      end
-
-      def process(node)
-        return super if @nokogiri_setup
-        @nokogiri_setup = Set.new
-        result = super
-
-        if @nokogiri_setup.empty?
-          result
-        else
-          setup = @esm ? ESM_SETUP : CJS_SETUP;
-          s(:begin, 
-            *@nokogiri_setup.to_a.map {|token| setup[token]}, result)
-        end
-      end
+      IMPORT_JSDOM = s(:import, ["jsdom"], [s(:attr, nil, :JSDOM)])
 
       def on_send(node)
         target, method, *args = node.children
@@ -55,7 +29,7 @@ module Ruby2JS
           [:HTML, :HTML5].include? method and
           target == s(:const, nil, :Nokogiri)
         then
-          @nokogiri_setup << :jsdom
+          prepend_list << IMPORT_JSDOM
           S(:attr, s(:attr, s(:send, s(:const, nil, :JSDOM), :new,
             *process_all(args)), :window), :document)
 
@@ -65,7 +39,7 @@ module Ruby2JS
           target.children.first == s(:const, nil, :Nokogiri) and
           [:HTML, :HTML5].include? target.children.last
         then
-          @nokogiri_setup << :jsdom
+          prepend_list << IMPORT_JSDOM
           S(:attr, s(:attr, s(:send, s(:const, nil, :JSDOM), :new,
             *process_all(args)), :window), :document)
 

data/lib/ruby2js/filter/return.rb

@@ -21,6 +21,8 @@ module Ruby2JS
       def on_def(node)
         node = super
         return node unless node.type == :def
+        return node if [:constructor, :initialize].include?(node.children.first)
+
         children = node.children[1..-1]
 
         children[-1] = s(:nil) if children.last == nil

data/lib/ruby2js/filter/securerandom.rb

@@ -0,0 +1,33 @@
+require 'ruby2js'
+require 'set'
+
+# Experimental secure random support
+
+module Ruby2JS
+  module Filter
+    module SecureRandom
+      include SEXP
+      extend SEXP
+
+      IMPORT_BASE62_RANDOM = s(:import, ['base62-random'],
+        s(:attr, nil, :base62_random))
+
+      def on_send(node)
+        target, method, *args = node.children
+
+        if target == s(:const, nil, :SecureRandom)
+          if method == :alphanumeric and args.length == 1
+            prepend_list << IMPORT_BASE62_RANDOM
+            node.updated(nil, [nil, :base62_random, *args])
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+    end
+
+    DEFAULTS.push SecureRandom
+  end
+end

data/lib/ruby2js/filter/vue.rb

@@ -106,6 +106,7 @@ module Ruby2JS
         computed = []
         setters = []
         options = []
+        watch = nil
         el = nil
         mixins = []
 
@@ -205,6 +206,9 @@ module Ruby2JS
                 end
 
                 @vue_h = args.children.first.children.last
+              elsif method == :watch and args.children.length == 0 and block.type == :hash
+                watch = process(block)
+                next
               elsif method == :initialize
                 method = :data
 
@@ -332,6 +336,11 @@ module Ruby2JS
           hash << s(:pair, s(:sym, :computed), s(:hash, *computed))
         end
 
+        # append watch to hash
+        if watch
+          hash << s(:pair, s(:sym, :watch), watch)
+        end
+
         # convert class name to camel case
         cname = cname.children.last
         camel = cname.to_s.gsub(/[^\w]/, '-').