ruby2js 3.3.5 → 3.5.2

data/lib/ruby2js/filter/esm_migration.rb

@@ -0,0 +1,72 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module ESMMigration
+      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 ESMMigration
+  end
+end

data/lib/ruby2js/filter/fast-deep-equal.rb

@@ -0,0 +1,23 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module Fast_Deep_Equal
+      include SEXP
+
+      SCALAR = [ :float, :int, :nil, :str ]
+
+      def on_send(node)
+        return super unless node.children.length == 3
+        left, method, right = node.children
+        return super unless method == :==
+        return super if SCALAR.include? left.type
+        return super if SCALAR.include? right.type
+
+        node.updated nil, [nil, :$eq, left, right]
+      end
+    end
+
+    DEFAULTS.push Fast_Deep_Equal
+  end
+end

data/lib/ruby2js/filter/functions.rb

@@ -528,6 +528,18 @@ module Ruby2JS
         elsif method == :new and target == s(:const, nil, :Exception)
           process S(:send, s(:const, nil, :Error), :new, *args)
 
+        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)
+
         else
           super
         end
@@ -538,7 +550,7 @@ module Ruby2JS
         method = call.children[1]
         return super if excluded?(method)
 
-        if [:setInterval, :setTimeout].include? method
+        if [:setInterval, :setTimeout, :set_interval, :set_timeout].include? method
           return super unless call.children.first == nil
           block = process s(:block, s(:send, nil, :proc), *node.children[1..-1])
           on_send call.updated nil, [*call.children[0..1], block,
@@ -703,6 +715,17 @@ module Ruby2JS
           process call.updated(nil, [*call.children, s(:block,
             s(:send, nil, :proc), *node.children[1..-1])])
 
+        elsif method == :yield_self and call.children.length == 2
+          process node.updated(:send, [s(:block, s(:send, nil, :proc),
+            node.children[1], s(:autoreturn, node.children[2])),
+            :[], call.children[0]])
+
+        elsif method == :tap and call.children.length == 2
+          process node.updated(:send, [s(:block, s(:send, nil, :proc),
+            node.children[1], s(:begin, node.children[2],
+            s(:return, s(:lvar, node.children[1].children[0].children[0])))),
+            :[], call.children[0]])
+
         else
           super
         end

data/lib/ruby2js/filter/node.rb

@@ -1,37 +1,21 @@
 require 'ruby2js'
 require 'set'
 
+Ruby2JS.module_default ||= :cjs
+
 module Ruby2JS
   module Filter
     module Node
       include SEXP
       extend SEXP
 
-      NODE_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)))
-      }
-
-      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
-          s(:begin, *@node_setup.to_a.map {|token| NODE_SETUP[token]},
-            result)
-        end
-      end
+      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
@@ -44,7 +28,7 @@ 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,
@@ -72,38 +56,38 @@ module Ruby2JS
           target.type == :const and target.children.first == nil
         then
           if method == :read and args.length == 1
-            @node_setup << :fs
+            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),
@@ -114,7 +98,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),
@@ -122,24 +106,24 @@ 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
+            prepend_list << IMPORT_FS
             s(:send, s(:attr, nil, :fs), :symlinkSync, *process_all(args))
             
           elsif method == :truncate and args.length == 2
-            @node_setup << :fs
+            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
+            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))
             })
@@ -162,15 +146,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))
             })
@@ -182,21 +166,21 @@ module Ruby2JS
             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
+            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
+            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))
             })
@@ -204,7 +188,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),
@@ -215,14 +199,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,
@@ -242,16 +226,16 @@ module Ruby2JS
           elsif method == :pwd and args.length == 0
             s(:send, s(:attr, nil, :process), :cwd)
           elsif method == :entries
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             s(:send, s(:attr, nil, :fs), :readdirSync, *process_all(args))
           elsif method == :mkdir and args.length == 1
-            @node_setup << :fs
+            prepend_list << IMPORT_FS
             s(:send, s(:attr, nil, :fs), :mkdirSync, process(args.first))
           elsif method == :rmdir and args.length == 1
-            @node_setup << :fs
+            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
@@ -291,7 +275,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)
@@ -319,7 +303,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,29 +7,7 @@ module Ruby2JS
       include SEXP
       extend SEXP
 
-      NOKOGIRI_SETUP = {
-        jsdom: s(:casgn, nil, :JSDOM, 
-          s(:attr, s(:send, nil, :require, s(:str, "jsdom")), :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
-          s(:begin, 
-            *@nokogiri_setup.to_a.map {|token| NOKOGIRI_SETUP[token]},
-            result)
-        end
-      end
+      IMPORT_JSDOM = s(:import, ["jsdom"], [s(:attr, nil, :JSDOM)])
 
       def on_send(node)
         target, method, *args = node.children
@@ -51,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)
 
@@ -61,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/require.rb

@@ -38,8 +38,6 @@ module Ruby2JS
 
             filename = File.join(dirname, basename)
 
-            segments = basename.split(/[\/\\]/)
-
             if not File.file? filename and File.file? filename+".rb"
               filename += '.rb'
             elsif not File.file? filename and File.file? filename+".js.rb"

data/lib/ruby2js/filter/return.rb

@@ -8,16 +8,22 @@ module Ruby2JS
       EXPRESSIONS = [ :array, :float, :hash, :if, :int, :lvar, :nil, :send ]
 
       def on_block(node)
-        children = process_all(node.children)
+        node = super
+        return node unless node.type == :block
+        children = node.children.dup
 
         children[-1] = s(:nil) if children.last == nil
 
-        node.updated nil, [*node.children[0..1],
+        node.updated nil, [*children[0..1],
           s(:autoreturn, *children[2..-1])]
       end
 
       def on_def(node)
-        children = process_all(node.children[1..-1])
+        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