ruby2js 3.0.12 → 3.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33e8a99086fe503dbff4afab72211baf206981e2b0dd68174aa8cc2ea9a1d361
-  data.tar.gz: 9c86b76630c9c2dbe32032280db32e52b0569ba56ccfcafee0729f8f6d9d351c
+  metadata.gz: cdc199c50043c6bf4873bb097b7e92856023ff48baf112aa4c7e9487b749f89b
+  data.tar.gz: 3c374a3ca6f1591c61dbc36bf602507c5526aadbf8fbd17c3c6efe7a6e3ca0db
 SHA512:
-  metadata.gz: b8a0f54b473fa2494ac736232e8e60487a96923d9cd4df5635329c532726836d15a7b465744e7441016e811b153dcc22993d3e0b7013fa99696c18674f3f66fe
-  data.tar.gz: c7806d2aefa3449e3f2e07438fdea60a1b222d0bb866f51035ddd95da67a44a009df109ba39bf9ab2da6ba866c8bf4a8fb9652fca5bfea43e5c688307b9141af
+  metadata.gz: '02917c6c3e994817a8bbf67aede8dbfa16dbe4d6ee48b7503f763795ddb22ed57b07427179ead407b8036e7c4e36d4fa6848edef7a4951bf39e183f4547e4666'
+  data.tar.gz: 496ad88241844101e583205e33f0d7604296801100e1a8870ec2b2f971110f873048d33ed4e7fac4f347bf05d8c545e64867b1b0ff5100dda96c97a98d7f51d6

data/README.md

@@ -124,10 +124,10 @@ quite different if `a` is a Hash.
 
 One way to resolve this is to change the way indexing operators are evaluated,
 and to provide a runtime library that adds properties to global JavaScript
-objects to handle this.  This is the approach that [Opal](http://opalrb.org/)
+objects to handle this.  This is the approach that [Opal](http://opalrb.com/)
 takes.  It is a fine approach, with a number of benefits.  It also has some
 notable drawbacks.  For example,
-[readability](http://opalrb.org/try/#code:a%20%3D%20%22abc%22%3B%20puts%20a[-1])
+[readability](http://opalrb.com/try/#code:a%20%3D%20%22abc%22%3B%20puts%20a[-1])
 and
 [compatibility with other frameworks](https://github.com/opal/opal/issues/400).
 
@@ -229,7 +229,7 @@ the script.
     * `.find_index` becomes `findIndex`
     * `.first` becomes `[0]`
     * `.first(n)` becomes `.slice(0, n)`
-    * `.gsub` becomes `replace //g`
+    * `.gsub` becomes `replace(//g)`
     * `.include?` becomes `.indexOf() != -1`
     * `.inspect` becomes `JSON.stringify()`
     * `.keys` becomes `Object.keys()`
@@ -243,6 +243,7 @@ the script.
     * `puts` becomes `console.log`
     * `.replace` becomes `.length = 0; ...push.apply(*)`
     * `.respond_to?` becomes `right in left`
+    * `.scan` becomes `.match(//g)`
     * `.start_with?` becomes `.substring(0, arg.length) == arg`
     * `.upto(lim)` becomes `for (var i=num; i<=lim; i+=1)`
     * `.downto(lim)` becomes `for (var i=num; i>=lim; i-=1)`
@@ -281,6 +282,91 @@ the script.
 
     * `.class` becomes `.constructor`
 
+* <a id="node" * href="https://github.com/rubys/ruby2js/blob/master/spec/node_spec.rb">node</a>
+
+    * `` `command` `` becomes `child_process.execSync("command", {encoding: "utf8"})`
+    * `ARGV` becomes `process.argv.slice(2)`
+    * `__dir__` becomes `__dirname`
+    * `Dir.chdir` becomes `process.chdir`
+    * `Dir.entries` becomes `fs.readdirSync`
+    * `Dir.mkdir` becomes `fs.mkdirSync`
+    * `Dir.mktmpdir` becomes `fs.mkdtempSync`
+    * `Dir.pwd` becomes `process.cwd`
+    * `Dir.rmdir` becomes `fs.rmdirSync`
+    * `ENV` becomes `process.env`
+    * `__FILE__` becomes `__filename`
+    * `File.chmod` becomes `fs.chmodSync`
+    * `File.chown` becomes `fs.chownSync`
+    * `File.cp` becomes `fs.copyFileSync`
+    * `File.exist?` becomes `fs.existsSync`
+    * `File.lchmod` becomes `fs.lchmodSync`
+    * `File.link` becomes `fs.linkSync`
+    * `File.ln` becomes `fs.linkSync`
+    * `File.lstat` becomes `fs.lstatSync`
+    * `File.read` becomes `fs.readFileSync`
+    * `File.readlink` becomes `fs.readlinkSync`
+    * `File.realpath` becomes `fs.realpathSync`
+    * `File.rename` becomes `fs.renameSync`
+    * `File.stat` becomes `fs.statSync`
+    * `File.symlink` becomes `fs.symlinkSync`
+    * `File.truncate` becomes `fs.truncateSync`
+    * `File.unlink` becomes `fs.unlinkSync`
+    * `FileUtils.cd` becomes `process.chdir`
+    * `FileUtils.cp` becomes `fs.copyFileSync`
+    * `FileUtils.ln` becomes `fs.linkSync`
+    * `FileUtils.ln_s` becomes `fs.symlinkSync`
+    * `FileUtils.mkdir` becomes `fs.mkdirSync`
+    * `FileUtils.mv` becomes `fs.renameSync`
+    * `FileUtils.pwd` becomes `process.cwd`
+    * `FileUtils.rm` becomes `fs.unlinkSync`
+    * `IO.read` becomes `fs.readFileSync`
+    * `IO.write` becomes `fs.writeFileSync`
+    * `system` becomes `child_process.execSync(..., {stdio: "inherit"})`
+
+* <a id="nokogiri" href="https://github.com/rubys/ruby2js/blob/master/spec/nokogiri.rb">nokogiri</a>
+    * `add_child` becomes `appendChild`
+    * `add_next_sibling` becomes `node.parentNode.insertBefore(sibling, node.nextSibling)`
+    * `add_previous_sibling` becomes `node.parentNode.insertBefore(sibling, node)`
+    * `after` becomes `node.parentNode.insertBefore(sibling, node.nextSibling)`
+    * `at` becomes `querySelector`
+    * `attr` becomes `getAttribute`
+    * `attribute` becomes `getAttributeNode`
+    * `before` becomes `node.parentNode.insertBefore(sibling, node)`
+    * `cdata?` becomes `node.nodeType === Node.CDATA_SECTION_NODE`
+    * `children` becomes `childNodes`
+    * `comment?` becomes `node.nodeType === Node.COMMENT_NODE`
+    * `content` becomes `textContent`
+    * `create_element` becomes `createElement`
+    * `document` becomes `ownerDocument`
+    * `element?` becomes `node.nodeType === Node.ELEMENT_NODE`
+    * `fragment?` becomes `node.nodeType === Node.FRAGMENT_NODE`
+    * `get_attribute` becomes `getAttribute`
+    * `has_attribute` becomes `hasAttribute`
+    * `inner_html` becomes `innerHTML`
+    * `key?` becomes `hasAttribute`
+    * `name` becomes `nextSibling`
+    * `next` becomes `nodeName`
+    * `next=` becomes `node.parentNode.insertBefore(sibling,node.nextSibling)`
+    * `next_element` becomes `nextElement`
+    * `next_sibling` becomes `nextSibling`
+    * `Nokogiri::HTML5` becomes `new JSDOM().window.document`
+    * `Nokogiri::HTML5.parse` becomes `new JSDOM().window.document`
+    * `Nokogiri::HTML` becomes `new JSDOM().window.document`
+    * `Nokogiri::HTML.parse` becomes `new JSDOM().window.document`
+    * `Nokogiri::XML::Node.new` becomes `document.createElement()`
+    * `parent` becomes `parentNode`
+    * `previous=` becomes `node.parentNode.insertBefore(sibling, node)`
+    * `previous_element` becomes `previousElement`
+    * `previous_sibling` becomes `previousSibling`
+    * `processing_instruction?` becomes `node.nodeType === Node.PROCESSING_INSTRUCTION_NODE`
+    * `remove_attribute` becomes `removeAttribute`
+    * `root` becomes `documentElement`
+    * `search` becomes `querySelectorAll`
+    * `set_attribute` becomes `setAttribute`
+    * `text?` becomes `node.nodeType === Node.TEXT_NODE`
+    * `text` becomes `textContent`
+    * `to_html` becomes `outerHTML`
+
 * <a id="rubyjs" href="https://github.com/rubys/ruby2js/blob/master/spec/rubyjs_spec.rb">rubyjs</a>
     * `.at()` becomes `_a.at()`
     * `.between?()` becomes `R().between()`
@@ -417,6 +503,14 @@ the script.
     * maps `assert_operator`, `refute_operator`, `.must_be`, and `.cant_be`
        calls to `expect`...`toBeGreaterThan()` or `toBeLessThan` calls
 
+* <a id="cjs" href="https://github.com/rubys/ruby2js/blob/master/spec/cjs">cjs</a>
+    * maps `export def f` to `exports.f =`
+    * maps `export async def f` to `exports.f = async`
+    * maps `export v =` to `exports.v =`
+    * maps `export default proc` to `module.exports =`
+    * maps `export default async proc` to `module.exports = async`
+    * maps `export default` to `module.exports =`
+
 [Wunderbar](https://github.com/rubys/wunderbar) includes additional demos:
 
 * [chat](https://github.com/rubys/wunderbar/blob/master/demo/chat.rb),
@@ -480,14 +574,14 @@ Picking a Ruby to JS mapping tool
 
 If you simply want to get a job done, and would like a mature and tested
 framework, and only use one of the many integrations that
-[Opal](http://opalrb.org/) provides, then Opal is the way to go right now.
+[Opal](http://opalrb.com/) provides, then Opal is the way to go right now.
 
 ruby2js is for those that want to produce JavaScript that looks like it
 wasn’t machine generated, and want the absolute bare minimum in terms of
 limitations as to what JavaScript can be produced.
 
-[Try](http://intertwingly.net/projects/ruby2js/all) for yourself.
-[Compare](http://opalrb.org/try/#code:).
+[Try](http://intertwingly.net/projects/ruby2js.cgi/all) for yourself.
+[Compare](http://opalrb.com/try/#code:).
 
 And, of course, the right solution might be to use
 [CoffeeScript](http://coffeescript.org/) instead.

data/lib/ruby2js.rb

@@ -113,6 +113,7 @@ module Ruby2JS
       def on_prototype(node); on_begin(node); end
       def on_sendw(node); on_send(node); end
       def on_undefined?(node); on_defined?(node); end
+      def on_nil(node); end
 
       # provide a method so filters can call 'super'
       def on_sym(node); node; end
@@ -195,8 +196,12 @@ module Ruby2JS
     ruby2js
   end
   
-  def self.parse(source, file=nil)
-    Parser::CurrentRuby.parse_with_comments(source.encode('utf-8'), file)
+  def self.parse(source, file=nil, line=1)
+    buffer = Parser::Source::Buffer.new(file, line)
+    buffer.source = source.encode('utf-8')
+    parser = Parser::CurrentRuby.new
+    parser.builder.emit_file_line_as_literals=false
+    parser.parse_with_comments(buffer)
   rescue Parser::SyntaxError => e
     split = source[0..e.diagnostic.location.begin_pos].split("\n")
     line, col = split.length, split.last.length

data/lib/ruby2js/converter.rb

@@ -12,7 +12,7 @@ module Ruby2JS
 
   class Converter < Serializer
     attr_accessor :ast
-
+    
     LOGICAL   = :and, :not, :or
     OPERATORS = [:[], :[]=], [:not, :!], [:**], [:*, :/, :%], [:+, :-], 
       [:>>, :<<], [:&], [:^, :|], [:<=, :<, :>, :>=], [:==, :!=, :===, :"!=="],
@@ -201,9 +201,11 @@ module Ruby2JS
       sep = @options[:join].to_s
       state = @options[:state] || :expression
 
-      args.each_with_index do |arg, index|
+      index = 0
+      args.each do |arg|
         put sep unless index == 0
         parse arg, state
+        index += 1 unless arg == s(:begin)
       end
     end
     
@@ -288,6 +290,7 @@ require 'ruby2js/converter/def'
 require 'ruby2js/converter/defs'
 require 'ruby2js/converter/defined'
 require 'ruby2js/converter/dstr'
+require 'ruby2js/converter/fileline'
 require 'ruby2js/converter/for'
 require 'ruby2js/converter/hash'
 require 'ruby2js/converter/if'

data/lib/ruby2js/converter/class.rb

@@ -126,7 +126,7 @@ module Ruby2JS
             s(:send, s(:block, s(:send, nil, :lambda), s(:args),
               s(:begin, *m.children[2..-1].map {|modname|
               s(:for, s(:lvasgn, :$_), modname,
-              s(:send, s(:send, name, :prototype), :[]=,
+              s(:send, s(:attr, name, :prototype), :[]=,
               s(:lvar, :$_), s(:send, modname, :[], s(:lvar, :$_))))
               })), :[])
           elsif [:private, :protected, :public].include? m.children[1]

data/lib/ruby2js/converter/fileline.rb

@@ -0,0 +1,11 @@
+module Ruby2JS
+  class Converter
+
+    # (true)
+    # (false)
+
+    handle :__FILE__, :__LINE__ do
+      put @ast.type.to_s
+    end
+  end
+end

data/lib/ruby2js/converter/literal.rb

@@ -8,5 +8,9 @@ module Ruby2JS
     handle :int, :float, :str do |value|
       put value.inspect
     end
+
+    handle :octal do |value|
+      put '0' + value.to_s(8)
+    end
   end
 end

data/lib/ruby2js/converter/send.rb

@@ -124,10 +124,25 @@ module Ruby2JS
 
       elsif method == :[]
         (group_receiver ? group(receiver) : parse(receiver))
-        put '['; parse_all(*args, join: ', '); put ']'
+        if
+          args.length == 1 and [:str, :sym].include? args.first.type and
+          args.first.children.first.to_s =~ /^[a-zA-Z]\w*$/
+        then
+          put ".#{args.first.children.first}"
+        else
+          put '['; parse_all(*args, join: ', '); put ']'
+        end
 
       elsif method == :[]=
-        parse receiver; put '['; parse_all(*args[0..-2], join: ', '); put '] = '
+        parse receiver
+        if
+          args.length == 2 and [:str, :sym].include? args.first.type and
+          args.first.children.first.to_s =~ /^[a-zA-Z]\w*$/
+        then
+          put ".#{args.first.children.first} = "
+        else
+          put '['; parse_all(*args[0..-2], join: ', '); put '] = '
+        end
         parse args[-1]
 
       elsif method == :** and not es2016
@@ -245,6 +260,8 @@ module Ruby2JS
           if receiver
             (group_receiver ? group(receiver) : parse(receiver))
             put ".#{ method }"
+          elsif ast.type == :attr
+            put method
           else
             parse ast.updated(:lvasgn, [method]), @state
           end

data/lib/ruby2js/filter.rb

@@ -42,15 +42,6 @@ module Ruby2JS
       end
     end
 
-    # indicate that the specified methods are not to be processed
-    def self.exclude(*methods)
-      if @@included
-        @@included -= methods.flatten
-      else
-        @@excluded += methods.flatten
-      end
-    end
-
     #
     # instance level overrides
     #

data/lib/ruby2js/filter/cjs.rb

@@ -0,0 +1,92 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module CJS
+      include SEXP
+
+      def on_send(node)
+        return super unless node.children[1] == :export
+
+        if node.children[2].type == :def
+          fn = node.children[2]
+          node.updated(nil, [
+            s(:attr, nil, :exports),
+            fn.children[0].to_s + '=',
+            s(:block, s(:send, nil, :proc), *process_all(fn.children[1..-1]))
+          ])
+
+        elsif node.children[2].type == :lvasgn
+          assign = node.children[2]
+          node.updated(nil, [
+            s(:attr, nil, :exports),
+            assign.children[0].to_s + '=',
+            *assign.children[1..-1]
+          ])
+
+        elsif 
+          node.children[2].type == :send and
+          node.children[2].children[0..1] == [nil, :async] and
+          node.children[2].children[2].type == :def
+        then
+          fn = node.children[2].children[2]
+          node.updated(nil, [
+            s(:attr, nil, :exports),
+            fn.children[0].to_s + '=',
+            s(:send, nil, :async,
+              s(:block, s(:send, nil, :proc),
+              *process_all(fn.children[1..-1])))
+          ])
+
+        elsif 
+          node.children[2].type == :send and
+          node.children[2].children[0..1] == [nil, :default]
+        then
+          node = node.children[2]
+
+          node.updated(nil, [
+            s(:attr, nil, :module),
+            :exports=,
+            node.children[2]
+          ])
+
+        else
+          super
+        end
+      end
+
+      def on_block(node)
+        child = node.children[0]
+        unless child.type == :send and child.children[0..1] == [nil, :export]
+          return super 
+        end
+
+        send = child.children[2]
+        unless send.type == :send and send.children[0..1] == [nil, :default]
+          return super 
+        end
+
+        if send.children[2] == s(:send, nil, :proc)
+          node.updated(:send, [
+            s(:attr, nil, :module),
+            :exports=,
+            s(:block, s(:send, nil, :proc),
+            *process_all(node.children[1..-1]))
+          ])
+        elsif send.children[2] == s(:send, nil, :async, s(:send, nil, :proc))
+          node.updated(:send, [
+            s(:attr, nil, :module),
+            :exports=,
+            s(:send, nil, :async,
+              s(:block, s(:send, nil, :proc),
+              *process_all(node.children[1..-1])))
+          ])
+        else
+          super
+        end
+      end
+    end
+
+    DEFAULTS.push CJS
+  end
+end

data/lib/ruby2js/filter/functions.rb

@@ -103,6 +103,33 @@ module Ruby2JS
             super
           end
 
+        elsif method == :scan and args.length == 1
+          arg = args.first
+          if arg.type == :str
+            arg = arg.updated(:regexp,
+              [s(:str, Regexp.escape(arg.children.first)), s(:regopt)])
+          end
+
+          pattern = arg.children.first.children.first
+          pattern = pattern.gsub(/\\./, '').gsub(/\[.*\]/, '')
+
+          if arg.type == :regexp
+            gpattern = arg.updated(:regexp, [*arg.children[0...-1],
+              s(:regopt, :g, *arg.children.last)])
+          else
+            super
+          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))))
+          else
+            S(:send, process(target), :match, gpattern)
+          end
+
         elsif method == :gsub and args.length == 2
           before, after = args
           if before.type == :regexp
@@ -238,7 +265,7 @@ module Ruby2JS
 
           elsif index.type == :regexp
             process S(:send, 
-              s(:or, S(:send, target, :match, index), s(:array)),
+              s(:or, S(:send, process(target), :match, index), s(:array)),
               :[], args[1] || s(:int, 0))
 
           elsif node.children.length != 3
@@ -249,21 +276,27 @@ module Ruby2JS
 
           elsif index.type == :erange
             start, finish = index.children
-            process S(:send, target, :slice, i.(start), i.(finish))
+            if finish.type == :int
+              process S(:send, target, :slice, i.(start), finish)
+            else
+              process S(:send, target, :slice, i.(start), i.(finish))
+            end
 
           elsif index.type == :irange
             start, finish = index.children
-            start = i.(start)
             if finish.type == :int
-              if finish.children.first == -1
-                finish = S(:attr, target, :length)
-              else
-                finish = i.(S(:int, finish.children.first+1))
-              end
+              final = S(:int, finish.children.first+1)
+            else
+              final = S(:send, finish, :+, s(:int, 1))
+            end
+
+            # No need for the last argument if it's -1
+            # This means take all to the end of array
+            if finish.children.first == -1
+              process S(:send, target, :slice, start)
             else
-              finish = S(:send, finish, :+, s(:int, 1))
+              process S(:send, target, :slice, start, final)
             end
-            process S(:send, target, :slice, start, finish)
 
           else
             super

data/lib/ruby2js/filter/node.rb

@@ -0,0 +1,341 @@
+require 'ruby2js'
+require 'set'
+
+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
+
+      def process(node)
+        return super if @node_setup
+        @node_setup = Set.new
+        result = super
+
+        if @node_setup.empty?
+          result
+        else
+          s(:begin, *@node_setup.to_a.map {|token| NODE_SETUP[token]},
+            result)
+        end
+      end
+
+      def on_send(node)
+        target, method, *args = node.children
+
+        if target == nil
+          if method == :__dir__ and args.length == 0
+            S(:attr, nil, :__dirname)
+
+          elsif method == :exit and args.length <= 1
+            s(:send, s(:attr, nil, :process), :exit, *process_all(args));
+
+          elsif method == :system
+            @node_setup << :child_process
+
+            if args.length == 1
+              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,
+              process(args.first), s(:array, *process_all(args[1..-1])),
+              s(:hash, s(:pair, s(:sym, :stdio), s(:str, 'inherit'))))
+            end
+
+          elsif 
+            method == :require and args.length == 1 and 
+            args.first.type == :str and 
+            %w(fileutils tmpdir).include? args.first.children.first
+          then
+            s(:begin)
+
+          else
+            super
+          end
+
+        elsif 
+          [:File, :IO].include? target.children.last and
+          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),
+              s(:str, 'utf8'))
+
+          elsif method == :write and args.length == 2
+            @node_setup << :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
+            S(:send, s(:attr, nil, :fs), :existsSync, process(args.first))
+
+          elsif method == :readlink and args.length == 1
+            @node_setup << :fs
+            S(:send, s(:attr, nil, :fs), :readlinkSync, process(args.first))
+
+          elsif method == :realpath and args.length == 1
+            @node_setup << :fs
+            S(:send, s(:attr, nil, :fs), :realpathSync, process(args.first))
+
+          elsif method == :rename and args.length == 2
+            @node_setup << :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
+
+            S(:begin, *args[1..-1].map{|file|
+              S(:send, s(:attr, nil, :fs), method.to_s + 'Sync', process(file),
+                s(:octal, *args.first.children))
+            })
+
+          elsif 
+            [:chown, :lchown].include? method and args.length > 2 and 
+            args[0].type == :int and args[1].type == :int
+          then
+            @node_setup << :fs
+
+            S(:begin, *args[2..-1].map{|file|
+              s(:send, s(:attr, nil, :fs), method.to_s + 'Sync', process(file),
+                *process_all(args[0..1]))
+            })
+
+          elsif [:ln, :link].include? method and args.length == 2
+            @node_setup << :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))
+            
+          elsif method == :truncate and args.length == 2
+            @node_setup << :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',
+              process(args.first))
+
+          elsif method == :unlink and args.length == 1
+            @node_setup << :fs
+            S(:begin, *args.map{|file|
+              S(:send, s(:attr, nil, :fs), :unlinkSync, process(file))
+            })
+
+          else
+            super
+          end
+
+        elsif 
+          target.children.last == :FileUtils and
+          target.type == :const and target.children.first == nil
+        then
+
+          list = proc do |arg|
+            if arg.type == :array
+              arg.children
+            else
+              [arg]
+            end
+          end
+            
+          if [:cp, :copy].include? method and args.length == 2
+            @node_setup << :fs
+            s(:send, s(:attr, nil, :fs), :copyFileSync, *process_all(args))
+            
+          elsif [:mv, :move].include? method and args.length == 2
+            @node_setup << :fs
+            S(:send, s(:attr, nil, :fs), :renameSync, *process_all(args))
+
+          elsif method == :mkdir and args.length == 1
+            @node_setup << :fs
+            S(:begin, *list[args.last].map {|file|
+              s(:send, s(:attr, nil, :fs), :mkdirSync, process(file))
+            })
+            
+          elsif method == :cd 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)
+
+          elsif method == :rmdir and args.length == 1
+            @node_setup << :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))
+            
+          elsif method == :ln_s and args.length == 2
+            @node_setup << :fs
+            s(:send, s(:attr, nil, :fs), :symlinkSync, *process_all(args))
+            
+          elsif method == :rm and args.length == 1
+            @node_setup << :fs
+            S(:begin, *list[args.last].map {|file|
+              s(:send, s(:attr, nil, :fs), :unlinkSync, process(file))
+            })
+
+          elsif 
+            method == :chmod and args.length == 2 and args.first.type == :int
+          then
+            @node_setup << :fs
+
+            S(:begin, *list[args.last].map {|file|
+              S(:send, s(:attr, nil, :fs), method.to_s + 'Sync', process(file),
+                s(:octal, *args.first.children))
+            })
+
+          elsif 
+            method == :chown and args.length == 3 and 
+            args[0].type == :int and args[1].type == :int
+          then
+            @node_setup << :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
+
+            S(:begin, *list[args.first].map {|file|
+              S(:send, s(:attr, nil, :fs), :closeSync,
+                s(:send, s(:attr, nil, :fs), :openSync, file,
+                s(:str, "w")))})
+
+          else
+            super
+          end
+
+        elsif 
+          target.type == :const and target.children.first == nil and
+          target.children.last == :Dir
+        then
+          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)
+          elsif method == :entries
+            @node_setup << :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))
+          elsif method == :rmdir and args.length == 1
+            @node_setup << :fs
+            s(:send, s(:attr, nil, :fs), :rmdirSync, process(args.first))
+          elsif method == :mktmpdir and args.length <=1
+            @node_setup << :fs
+            if args.length == 0
+              prefix = s(:str, 'd')
+            elsif args.first.type == :array
+              prefix = args.first.children.first
+            else
+              prefix = args.first
+            end
+
+            s(:send, s(:attr, nil, :fs), :mkdtempSync, process(prefix))
+          else
+            super
+          end
+
+        else
+          super
+        end
+      end
+
+      def on_block(node)
+        call = node.children.first
+        target, method, *args = call.children
+
+        if 
+          method == :chdir and args.length == 1 and
+          target.children.last == :Dir and
+          target.type == :const and target.children.first == nil
+        then
+          s(:begin,
+            s(:gvasgn, :$oldwd, s(:send, s(:attr, nil, :process), :cwd)),
+            s(:kwbegin, s(:ensure, 
+              s(:begin, process(call), process(node.children.last)),
+              s(:send, s(:attr, nil, :process), :chdir, s(:gvar, :$oldwd)))))
+        else
+          super
+        end
+      end
+
+      def on_const(node)
+        if node.children == [nil, :ARGV]
+          @node_setup << :ARGV
+          super
+        elsif node.children == [nil, :ENV]
+          S(:attr, s(:attr, nil, :process), :env)
+        elsif node.children == [nil, :STDIN]
+          S(:attr, s(:attr, nil, :process), :stdin)
+        elsif node.children == [nil, :STDOUT]
+          S(:attr, s(:attr, nil, :process), :stdout)
+        elsif node.children == [nil, :STDERR]
+          S(:attr, s(:attr, nil, :process), :stderr)
+        else
+          super
+        end
+      end
+
+      def on_gvar(node)
+        if node.children == [:$stdin]
+          S(:attr, s(:attr, nil, :process), :stdin)
+        elsif node.children == [:$stdout]
+          S(:attr, s(:attr, nil, :process), :stdout)
+        elsif node.children == [:$stderr]
+          S(:attr, s(:attr, nil, :process), :stderr)
+        else
+          super
+        end
+      end
+
+      def on_xstr(node)
+        @node_setup << :child_process
+
+        children = node.children.dup
+        command = children.shift
+        while children.length > 0
+          command = s(:send, accumulator, :+, children.shift)
+        end
+
+        s(:send, s(:attr, nil, :child_process), :execSync, command,
+          s(:hash, s(:pair, s(:sym, :encoding), s(:str, 'utf8'))))
+      end
+
+      def on___FILE__(node)
+        s(:attr, nil, :__filename)
+      end
+    end
+
+    DEFAULTS.push Node
+  end
+end

data/lib/ruby2js/filter/nokogiri.rb

@@ -0,0 +1,261 @@
+require 'ruby2js'
+require 'set'
+
+module Ruby2JS
+  module Filter
+    module Nokogiri
+      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
+
+      def on_send(node)
+        target, method, *args = node.children
+        return super if excluded?(method)
+
+        if target == nil
+          if 
+            method == :require and args.length == 1 and 
+            args.first.type == :str and 
+            %w(nokogiri nokogumbo).include? args.first.children.first
+          then
+            s(:begin)
+
+          else
+            super
+          end
+
+        elsif 
+          [:HTML, :HTML5].include? method and
+          target == s(:const, nil, :Nokogiri)
+        then
+          @nokogiri_setup << :jsdom
+          S(:attr, s(:attr, s(:send, s(:const, nil, :JSDOM), :new,
+            *process_all(args)), :window), :document)
+
+        elsif 
+          method == :parse and
+          target.type == :const and
+          target.children.first == s(:const, nil, :Nokogiri) and
+          [:HTML, :HTML5].include? target.children.last
+        then
+          @nokogiri_setup << :jsdom
+          S(:attr, s(:attr, s(:send, s(:const, nil, :JSDOM), :new,
+            *process_all(args)), :window), :document)
+
+        elsif 
+          method == :at and 
+          args.length == 1 and args.first.type == :str
+        then
+          S(:send, 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))
+
+        elsif method === :parent and args.length == 0
+          S(:attr, target, :parentNode)
+
+        elsif method === :name and args.length == 0
+          S(:attr, target, :nodeName)
+
+        elsif [:text, :content].include? method and args.length == 0
+          S(:attr, target, :textContent)
+
+        elsif method == :content= and args.length == 1
+          S(:send, target, :textContent=, *process_all(args))
+
+        elsif method === :inner_html and args.length == 0
+          S(:attr, target, :innerHTML)
+
+        elsif method == :inner_html= and args.length == 1
+          S(:send, target, :innerHTML=, *process_all(args))
+
+        elsif method === :to_html and args.length == 0
+          S(:attr, 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))
+
+        elsif 
+          [:key?, :has_attribute].include? method and 
+          args.length == 1 and args.first.type == :str
+        then
+          S(:send, target, :hasAttribute, process(args.first))
+
+        elsif 
+          method == :set_attribute and 
+          args.length == 2 and args.first.type == :str
+        then
+          S(:send, target, :setAttribute, *process_all(args))
+
+        elsif 
+          method == :attribute and 
+          args.length == 1 and args.first.type == :str
+        then
+          S(:send, target, :getAttributeNode, *process_all(args))
+
+        elsif method == :remove_attribute and args.length == 1
+          S(:send, target, :removeAttribute, process(args.first))
+
+        elsif method == :attribute_nodes and args.length == 0
+          S(:attr, target, :attributes)
+
+        elsif 
+          method == :new and args.length == 2 and
+          target == s(:const, s(:const, s(:const, nil, :Nokogiri), :XML), :Node)
+        then
+          S(:send, process(args.last), :createElement, process(args.first))
+
+        elsif method == :create_element
+          create = S(:send, target, :createElement, process(args.first))
+          if args.length == 1
+            create
+          elsif true
+            init = []
+            args[1..-1].each do |arg|
+              if arg.type == :hash
+                init += arg.children.map do |pair|
+                  s(:send, s(:gvar, :$_), :setAttribute,
+                    *process_all(pair.children))
+                end
+              elsif arg.type == :str
+                init << s(:send, s(:gvar, :$_), :content=, process(arg))
+              else
+                return super
+              end
+            end
+
+            S(:send, s(:block, s(:send, nil, :proc), s(:args),
+              s(:begin, s(:gvasgn, :$_, create), *init,
+              s(:return, s(:gvar, :$_)))), :[])
+          else
+            super
+          end
+
+        elsif method == :create_text and args.length == 1
+          create = S(:send, target, :createTextNode, process(args.first))
+
+        elsif method == :create_comment and args.length == 1
+          create = S(:send, target, :createComment, process(args.first))
+
+        elsif method == :create_cdata and args.length == 1
+          create = S(:send, target, :createCDATASection, process(args.first))
+
+        elsif method == :add_child and args.length == 1
+          S(:send, target, :appendChild, process(args.first))
+
+        elsif 
+          [:add_next_sibling, :next=, :after].include? method and
+          args.length == 1
+        then
+          S(:send, s(:attr, 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,
+            process(args.first), target)
+
+        elsif method == :prepend_child and args.length == 1
+          S(:send, target, :insertBefore,
+            process(args.first), s(:attr, target, :firstChild))
+
+        elsif method == :next_element and args.length == 0
+          S(:attr, target, :nextElement)
+
+        elsif [:next, :next_sibling].include? method and args.length == 0
+          S(:attr, target, :nextSibling)
+
+        elsif method == :previous_element and args.length == 0
+          S(:attr, target, :previousElement)
+
+        elsif 
+          [:previous, :previous_sibling].include? method and args.length == 0
+        then
+          S(:attr, target, :previousSibling)
+
+        elsif method == :cdata? and args.length == 0
+          S(:send, s(:attr, target, :nodeType), :===,
+            s(:attr, s(:const, nil, :Node), :CDATA_SECTION_NODE))
+
+        elsif method == :comment? and args.length == 0
+          S(:send, s(:attr, target, :nodeType), :===,
+            s(:attr, s(:const, nil, :Node), :COMMENT_NODE))
+
+        elsif method == :element? and args.length == 0
+          S(:send, s(:attr, target, :nodeType), :===,
+            s(:attr, s(:const, nil, :Node), :ELEMENT_NODE))
+
+        elsif method == :fragment? and args.length == 0
+          S(:send, s(:attr, target, :nodeType), :===,
+            s(:attr, s(:const, nil, :Node), :DOCUMENT_FRAGMENT_NODE))
+
+        elsif method == :processing_instruction? and args.length == 0
+          S(:send, s(:attr, target, :nodeType), :===,
+            s(:attr, s(:const, nil, :Node), :PROCESSING_INSTRUCTION_NODE))
+
+        elsif method == :text? and args.length == 0
+          S(:send, s(:attr, target, :nodeType), :===,
+            s(:attr, s(:const, nil, :Node), :TEXT_NODE))
+
+        elsif method == :children and args.length == 0
+          S(:attr, target, :childNodes)
+
+        elsif method == :first_element_child and args.length == 0
+          S(:attr, target, :firstElementChild)
+
+        elsif method == :last_element_child and args.length == 0
+          S(:attr, target, :lastElementChild)
+
+        elsif method == :replace and args.length == 1
+          S(:send, target, :replaceWith, process(args.first))
+
+        elsif [:remove, :unlink].include? method and args.length == 0
+          S(:send, target, :remove)
+
+        elsif method == :root and args.length == 0
+          S(:attr, target, :documentElement)
+
+        elsif method == :document and args.length == 0
+          S(:attr, target, :ownerDocument)
+
+        else
+          return super
+
+        end
+      end
+    end
+
+    DEFAULTS.push Nokogiri
+  end
+end

data/lib/ruby2js/filter/vue.rb

@@ -216,6 +216,8 @@ module Ruby2JS
                       s(:attr, nil, :undefined))
                   end
 
+                  next if pairs.empty? and @comments[statement].empty?
+
                   block = s(:return, s(:hash, *pairs))
                 else
                   # general case: build up a hash incrementally

data/lib/ruby2js/version.rb

@@ -2,7 +2,7 @@ module Ruby2JS
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 0
-    TINY  = 12
+    TINY  = 13
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby2js
 version: !ruby/object:Gem::Version
-  version: 3.0.12
+  version: 3.0.13
 platform: ruby
 authors:
 - Sam Ruby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-16 00:00:00.000000000 Z
+date: 2018-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -56,6 +56,7 @@ files:
 - lib/ruby2js/converter/defined.rb
 - lib/ruby2js/converter/defs.rb
 - lib/ruby2js/converter/dstr.rb
+- lib/ruby2js/converter/fileline.rb
 - lib/ruby2js/converter/for.rb
 - lib/ruby2js/converter/hash.rb
 - lib/ruby2js/converter/if.rb
@@ -95,9 +96,12 @@ files:
 - lib/ruby2js/execjs.rb
 - lib/ruby2js/filter.rb
 - lib/ruby2js/filter/camelCase.rb
+- lib/ruby2js/filter/cjs.rb
 - lib/ruby2js/filter/functions.rb
 - lib/ruby2js/filter/jquery.rb
 - lib/ruby2js/filter/minitest-jasmine.rb
+- lib/ruby2js/filter/node.rb
+- lib/ruby2js/filter/nokogiri.rb
 - lib/ruby2js/filter/react.rb
 - lib/ruby2js/filter/require.rb
 - lib/ruby2js/filter/return.rb