ruby2js 3.5.1 → 4.0.0

data/lib/ruby2js/filter/{wunderbar.rb → jsx.rb}

@@ -1,17 +1,19 @@
 require 'ruby2js'
 
+# Convert Wunderbar syntax to JSX
+
 module Ruby2JS
   module Filter
-    module Wunderbar
+    module JSX
       include SEXP
 
       def on_send(node)
-        target, method, *attrs = node.children
+        target, method, *args = node.children
 
         if target == s(:const, nil, :Wunderbar)
           if [:debug, :info, :warn, :error, :fatal].include? method
             method = :error if method == :fatal
-            return node.updated(nil, [s(:const, nil, :console), method, *attrs])
+            return node.updated(nil, [s(:const, nil, :console), method, *args])
           end
         end
 
@@ -27,7 +29,17 @@ module Ruby2JS
         end
 
         if target == nil and method.to_s.start_with? "_"
-          S(:xnode, *method.to_s[1..-1], *stack, *process_all(attrs))
+          S(:xnode, method.to_s[1..-1], *stack, *process_all(args))
+
+        elsif method == :createElement and target == s(:const, nil, :React)
+          if args.first.type == :str and \
+            (args.length == 1 or %i(nil hash).include? args[1].type)
+            attrs = (args[1]&.type != :nil && args[1]) || s(:hash)
+            S(:xnode, args[0].children.first, attrs, *process_all(args[2..-1]))
+          else
+            super
+          end
+
         else
           super
         end
@@ -42,8 +54,18 @@ module Ruby2JS
 
         if target == nil and method.to_s.start_with? "_"
           if args.children.empty?
-            # append block as a standalone proc
-            process send.updated(nil, [*send.children, *process_all(block)])
+            if method == :_
+              # Fragment
+              if send.children.length == 2
+                process send.updated(:xnode, ['', *process_all(block)])
+              else
+                process s(:xnode, 'React.Fragment', *send.children[2..-1],
+                  *process_all(block))
+              end
+            else
+              # append block as a standalone proc
+              process send.updated(nil, [*send.children, *process_all(block)])
+            end
           else
             # iterate over Enumerable arguments if there are args present
             send = send.children
@@ -58,6 +80,6 @@ module Ruby2JS
       end
     end
 
-    DEFAULTS.push Wunderbar
+    DEFAULTS.push JSX
   end
 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

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)
 
@@ -73,40 +47,40 @@ module Ruby2JS
           method == :at and 
           args.length == 1 and args.first.type == :str
         then
-          S(:send, target, :querySelector, process(args.first))
+          S(:send, process(target), :querySelector, process(args.first))
 
         elsif \
           method == :search and 
           args.length == 1 and args.first.type == :str
         then
-          S(:send, target, :querySelectorAll, process(args.first))
+          S(:send, process(target), :querySelectorAll, process(args.first))
 
         elsif method === :parent and args.length == 0
-          S(:attr, target, :parentNode)
+          S(:attr, process(target), :parentNode)
 
         elsif method === :name and args.length == 0
-          S(:attr, target, :nodeName)
+          S(:attr, process(target), :nodeName)
 
         elsif [:text, :content].include? method and args.length == 0
-          S(:attr, target, :textContent)
+          S(:attr, process(target), :textContent)
 
         elsif method == :content= and args.length == 1
-          S(:send, target, :textContent=, *process_all(args))
+          S(:send, process(target), :textContent=, *process_all(args))
 
         elsif method === :inner_html and args.length == 0
-          S(:attr, target, :innerHTML)
+          S(:attr, process(target), :innerHTML)
 
         elsif method == :inner_html= and args.length == 1
-          S(:send, target, :innerHTML=, *process_all(args))
+          S(:send, process(target), :innerHTML=, *process_all(args))
 
         elsif method === :to_html and args.length == 0
-          S(:attr, target, :outerHTML)
+          S(:attr, process(target), :outerHTML)
 
         elsif \
           [:attr, :get_attribute].include? method and 
           args.length == 1 and args.first.type == :str
         then
-          S(:send, target, :getAttribute, process(args.first))
+          S(:send, process(target), :getAttribute, process(args.first))
 
         elsif \
           [:key?, :has_attribute].include? method and 
@@ -180,14 +154,14 @@ module Ruby2JS
           [:add_next_sibling, :next=, :after].include? method and
           args.length == 1
         then
-          S(:send, s(:attr, target, :parentNode), :insertBefore,
+          S(:send, s(:attr, process(target), :parentNode), :insertBefore,
             process(args.first), s(:attr, target, :nextSibling))
 
         elsif \
           [:add_previous_sibling, :previous=, :before].include? method and
           args.length == 1
         then
-          S(:send, s(:attr, target, :parentNode), :insertBefore,
+          S(:send, s(:attr, process(target), :parentNode), :insertBefore,
             process(args.first), target)
 
         elsif method == :prepend_child and args.length == 1