ruby2js 3.5.3 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a0cc1907c261ee4de0bf29def31b92148ceb0b1247035db8553515106cc800b
-  data.tar.gz: 8141a424cf50daa57e96aea4d2a601b283377a05769e455c0c8f4ffadd3690ae
+  metadata.gz: 7fa9e6949c8d7d1f3f5cb549dc234a2b559d032bc9b5b236d123f68b62ecd763
+  data.tar.gz: e89542553f4db3caa7ceda112542a3a7fceb468d23d8a15cb9b416954c054d1f
 SHA512:
-  metadata.gz: 2836e4593b6f4fa15be750e8c83231e90c62d5bce75768119d4ba54b7b3459601018744eba95952db906d1e5ca64a40658d6449348239056cb9297647f424f88
-  data.tar.gz: f009c9829447798d8b1a21fc2cf6e6033cb21c22999d73f7289de08d03edbbd1ce35b1a6f125693803758e779a779379cbd78ed291a9224e4b7cbb0a257ef1ad
+  metadata.gz: a46d662b6be3a5e7a7242c1249705dcc5b705bfa984443ebedbb766c241aff365ce6f45fbea6b774f6646ce807c6d7f595becb841866f1a878ae65f69b409430
+  data.tar.gz: 27091e81578f5cebad30132ef54c3e08a1a32516233a0cab084c15dca5b361c7a2c7602dd3ba886d57db23301bb5a7d54d106cabba7a5a71d5989fc0b959533d

data/README.md

@@ -40,9 +40,6 @@ For example:
   * Any block becomes and explicit argument `new Promise do; y(); end` becomes `new Promise(function() {y()})`
   * regular expressions are mapped to js
   * `raise` becomes `throw`
-  * expressions enclosed in backtick operators (\`\`) and `%x{}` literals are
-    evaluated in the context of the caller and the results are inserted
-    into the generated JavaScript.
 
 Ruby attribute accessors, methods defined with no parameters and no
 parenthesis, as well as setter method definitions, are
@@ -87,6 +84,12 @@ Host variable substitution:
  puts Ruby2JS.convert("@name", ivars: {:@name => "Joe"})
 ```
 
+Host expression evalution -- potentially unsafe, use only if you trust
+the source being converted::
+```ruby
+ i = 7; puts Ruby2JS.convert("i = `i`", binding: binding)
+```
+
 Enable ES2015 support:
 
 ```ruby
@@ -135,7 +138,7 @@ Introduction
 
 JavaScript is a language where `0` is considered `false`, strings are
 immutable, and the behaviors for operators like `==` are, at best,
-[convoluted](http://zero.milosz.ca/).
+[convoluted](https://zero.milosz.ca/).
 
 Any attempt to bridge the semantics of Ruby and JavaScript will involve
 trade-offs.  Consider the following expression:
@@ -150,10 +153,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.com/)
+objects to handle this.  This is the approach that [Opal](https://opalrb.com/)
 takes.  It is a fine approach, with a number of benefits.  It also has some
 notable drawbacks.  For example,
-[readability](http://opalrb.com/try/#code:a%20%3D%20%22abc%22%3B%20puts%20a[-1])
+[readability](https://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).
 
@@ -175,7 +178,7 @@ negative at runtime.
 This quickly gets into gray areas.  `each` in Ruby is a common method that
 facilitates iteration over arrays.  `forEach` is the JavaScript equivalent.
 Mapping this is fine until you start using a framework like jQuery which
-provides a function named [each](http://api.jquery.com/jQuery.each/).
+provides a function named [each](https://api.jquery.com/jQuery.each/).
 
 Fortunately, Ruby provides `?` and `!` as legal suffixes for method names,
 Ruby2js filters do an exact match, so if you select a filter that maps `each`
@@ -198,9 +201,7 @@ Ruby2JS::Filter.exclude :each
 ```
 
 Static transformations and runtime libraries aren't aren’t mutually exclusive.
-With enough of each, one could reproduce any functionality desired.  Just be
-forewarned, that implementing a function like `method_missing` would require a
-_lot_ of work.
+With enough of each, one could reproduce any functionality desired.
 
 Integrations
 ---
@@ -280,6 +281,7 @@ the script.
     * `.respond_to?` becomes `right in left`
     * `.rstrip` becomes `.replace(/s+$/, "")`
     * `.scan` becomes `.match(//g)`
+    * `.sum` becomes `.reduce(function(a, b) {a + b}, 0)`
     * `.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)`
@@ -326,6 +328,20 @@ the script.
 
     * `.class` becomes `.constructor`
 
+* <a id="active_functions" href="https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/filter/active_functions.rb">active_functions</a>
+
+    Provides functionality inspired by Rails' ActiveSupport. Works in conjunction
+    with the tiny NPM dependency `@ruby2js/active-functions` which must be added to
+    your application.
+
+    * `value.blank?` becomes `blank$(value)`
+    * `value.present?` becomes `present$(value)`
+    * `value.presence` becomes `presence$(value)`
+
+    Note: these conversions are only done if eslevel >= 2015. Import statements
+    will be added to the top of the code output automatically. By default they
+    will be `@ruby2js/active-functions`, but you can pass an `import_from_skypack: true` option to `convert` to use the Skypack CDN instead.
+
 * <a id="tagged_templates" href="https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/filter/tagged_templates.rb">tagged_templates</a>
 
     Allows you to turn certain method calls with a string argument into tagged
@@ -391,6 +407,59 @@ the script.
     # => export { one, two, three as default }
     ```
 
+    If the "autoexports" option is `true`, all top level modules, classes, 
+    methods and constants will automatically be exported.
+
+    The esm filter also provides a way to specify "autoimports" when you run the
+    conversion. It will add the relevant import statements automatically whenever
+    a particular class or function name is referenced. These can be either default
+    or named exports. Simply provide an `autoimports` hash with one or more keys
+    to the `Ruby2JS.convert` method. Examples:
+
+    ```ruby
+    require "ruby2js/filter/esm"
+    puts Ruby2JS.convert('class MyElement < LitElement; end',
+      eslevel: 2020, autoimports: {[:LitElement] => "lit-element"})
+    ```
+
+    ```js
+    // JavaScript output:
+    import { LitElement } from "lit-element"
+    class MyElement extends LitElement {}
+    ```
+
+    ```ruby
+    require "ruby2js/filter/esm"
+    puts Ruby2JS.convert('AWN.new({position: "top-right"}).success("Hello World")',
+      eslevel: 2020, autoimports: {:AWN => "awesome-notifications"})
+    ```
+
+    ```js
+    // JavaScript output:
+    import AWN from "awesome-notifications"
+    new AWN({position: "top-right"}).success("Hello World")
+    ```
+
+    The esm filter is able to recognize if you are defining a class or function
+    within the code itself and it won't add that import statement accordingly.
+    If for some reason you wish to disable autoimports entirely on a file-by-file
+    basis (for instance when using the Webpack loader), you can add a magic comment
+    to the top of the code:
+
+    ```ruby
+    require "ruby2js/filter/esm"
+    puts Ruby2JS.convert(
+      "# autoimports: false\n" +
+      'AWN.new({position: "top-right"}).success("Hello World")',
+      eslevel: 2020, autoimports: {:AWN => "awesome-notifications"}
+    )
+    ```
+
+    ```js
+    // autoimports: false
+    new AWN({position: "top-right"}).success("Hello World")
+    ```
+
 * <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"})`
@@ -398,24 +467,34 @@ the script.
     * `__dir__` becomes `__dirname`
     * `Dir.chdir` becomes `process.chdir`
     * `Dir.entries` becomes `fs.readdirSync`
+    * `Dir.home` becomes `os.homedir()`
     * `Dir.mkdir` becomes `fs.mkdirSync`
     * `Dir.mktmpdir` becomes `fs.mkdtempSync`
     * `Dir.pwd` becomes `process.cwd`
     * `Dir.rmdir` becomes `fs.rmdirSync`
+    * `Dir.tmpdir` becomes `os.tmpdir()`
     * `ENV` becomes `process.env`
     * `__FILE__` becomes `__filename`
+    * `File.absolute_path` becomes `path.resolve`
+    * `File.absolute_path?` becomes `path.isAbsolute`
+    * `File.basename` becomes `path.basename`
     * `File.chmod` becomes `fs.chmodSync`
     * `File.chown` becomes `fs.chownSync`
     * `File.cp` becomes `fs.copyFileSync`
+    * `File.dirname` becomes `path.dirname`
     * `File.exist?` becomes `fs.existsSync`
+    * `File.extname` becomes `path.extname`
+    * `File.join` becomes `path.join`
     * `File.lchmod` becomes `fs.lchmodSync`
     * `File.link` becomes `fs.linkSync`
     * `File.ln` becomes `fs.linkSync`
     * `File.lstat` becomes `fs.lstatSync`
+    * `File::PATH_SEPARATOR` becomes `path.delimiter`
     * `File.read` becomes `fs.readFileSync`
     * `File.readlink` becomes `fs.readlinkSync`
     * `File.realpath` becomes `fs.realpathSync`
     * `File.rename` becomes `fs.renameSync`
+    * `File::SEPARATOR` becomes `path.sep`
     * `File.stat` becomes `fs.statSync`
     * `File.symlink` becomes `fs.symlinkSync`
     * `File.truncate` becomes `fs.truncateSync`
@@ -609,8 +688,16 @@ Additionally, the `functions` filter will provide the following conversion:
 * `Array(x)` becomes `Array.from(x)`
 * `.inject(n) {}` becomes `.reduce(() => {}, n)`
 
-Finally, keyword arguments and optional keyword arguments will be mapped to
-parameter detructuring.
+Keyword arguments and optional keyword arguments will be mapped to
+parameter destructuring.
+
+Classes defined with a `method_missing` method will emit a `Proxy` object
+for each instance that will forward calls.  Note that in order to forward
+arguments, this proxy will return a function that will need to be called,
+making it impossible to proxy attributes/getters.  As a special accommodation,
+if the `method_missing` method is defined to only accept a single parameter
+it will be called with only the method name, and it is free to return
+either values or functions.
 
 ES2016 support
 ---
@@ -619,6 +706,9 @@ When option `eslevel: 2016` is provided, the following additional
 conversion is made:
 
 * `a ** b` becomes `a ** b`
+
+Additionally the following conversions is added to the `functions` filter:
+
 * `.include?` becomes `.includes`
 
 ES2017 support
@@ -629,7 +719,7 @@ conversions are made by the `functions` filter:
 
 * `.values()` becomes `Object.values()`
 * `.entries()` becomes `Object.entries()`
-* `.each_pair {}` becomes `for (let [key, value] of Object.entries()) {}'
+* `.each_pair {}` becomes `for (let [key, value] of Object.entries()) {}`
 
 async support:
 
@@ -657,8 +747,8 @@ When option `eslevel: 2019` is provided, the following additional
 conversion is made by the `functions` filter:
 
 * `.flatten` becomes `.flat(Infinity)`
-* `.lstrip` becomes `.trimEnd
-* `.rstrip` becomes `.trimStart
+* `.lstrip` becomes `.trimEnd`
+* `.rstrip` becomes `.trimStart`
 * `a.to_h` becomes `Object.fromEntries(a)`
 * `Hash[a]` becomes `Object.fromEntries(a)`
 
@@ -684,27 +774,28 @@ conversions are made:
 
 * `x ||= 1` becomes `x ||= 1`
 * `x &&= 1` becomes `x &&= 1`
+* `1000000.000001` becomes `1_000_000.000_001`
 
 Picking a Ruby to JS mapping tool
 ---
 
 > dsl — A domain specific language, where code is written in one language and
 > errors are given in another.
-> -- [Devil’s Dictionary of Programming](http://programmingisterrible.com/post/65781074112/devils-dictionary-of-programming)
+> -- [Devil’s Dictionary of Programming](https://programmingisterrible.com/post/65781074112/devils-dictionary-of-programming)
 
 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.com/) provides, then Opal is the way to go right now.
+[Opal](https://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.cgi/all) for yourself.
-[Compare](http://opalrb.com/try/#code:).
+[Try](https://intertwingly.net/projects/ruby2js) for yourself.
+[Compare](https://opalrb.com/try/#code:).
 
 And, of course, the right solution might be to use
-[CoffeeScript](http://coffeescript.org/) instead.
+[CoffeeScript](https://coffeescript.org/) instead.
 
 License
 ---

data/lib/ruby2js.rb

@@ -61,13 +61,18 @@ module Ruby2JS
       include Ruby2JS::Filter
       BINARY_OPERATORS = Converter::OPERATORS[2..-1].flatten
 
-      attr_accessor :prepend_list
+      attr_accessor :prepend_list, :disable_autoimports
 
       def initialize(comments)
         @comments = comments
+
+        # check if magic comment is present:
+        first_comment = @comments.values.first&.map(&:text)&.first
+        @disable_autoimports = first_comment&.include?(" autoimports: false")
+        @disable_autoexports = first_comment&.include?(" autoexports: false")
+
         @ast = nil
         @exclude_methods = []
-        @esm = false
         @prepend_list = Set.new
       end
 
@@ -141,6 +146,7 @@ module Ruby2JS
       def on_method(node); on_send(node); end
       def on_prop(node); on_array(node); end
       def on_prototype(node); on_begin(node); end
+      def on_send!(node); on_send(node); end
       def on_sendw(node); on_send(node); end
       def on_undefined?(node); on_defined?(node); end
       def on_nil(node); end
@@ -188,7 +194,7 @@ module Ruby2JS
       source = ast.loc.expression.source_buffer.source
     else
       ast, comments = parse( source, options[:file] )
-      comments = Parser::Source::Comment.associate(ast, comments) if ast
+      comments = ast ? Parser::Source::Comment.associate(ast, comments) : {}
     end
 
     filters = (options[:filters] || Filter::DEFAULTS)
@@ -207,9 +213,10 @@ module Ruby2JS
       filter.options = options
       ast = filter.process(ast)
 
-      if filter.prepend_list
+      unless filter.prepend_list.empty?
         prepend = filter.prepend_list.sort_by {|ast| ast.type == :import ? 0 : 1}
-        ast = Parser::AST::Node.new(:begin, [*prepend, ast], location: ast.location)
+        prepend.reject! {|ast| ast.type == :import} if filter.disable_autoimports
+        ast = Parser::AST::Node.new(:begin, [*prepend, ast])
       end
     end
 
@@ -240,6 +247,8 @@ module Ruby2JS
 
     ruby2js.timestamp options[:file]
 
+    ruby2js.file_name = options[:file] || ast&.loc&.expression&.source_buffer&.name || ''
+
     ruby2js
   end
   

data/lib/ruby2js/converter.rb

@@ -248,7 +248,7 @@ module Ruby2JS
         if ast.loc and ast.loc.expression
           filename = ast.loc.expression.source_buffer.name
           if filename and not filename.empty?
-            @timestamps[filename] ||= File.mtime(filename)
+            @timestamps[filename] ||= File.mtime(filename) rescue nil
           end
         end
 

data/lib/ruby2js/converter/class2.rb

@@ -9,11 +9,22 @@ module Ruby2JS
     # NOTE: this is the es2015 version of class
 
     handle :class2 do |name, inheritance, *body|
+      body.compact!
+      while body.length == 1 and body.first.type == :begin
+        body = body.first.children 
+      end
+
+      proxied = body.find do |node| 
+        node.type == :def and node.children.first == :method_missing
+      end
+
       if name.type == :const and name.children.first == nil
         put 'class '
         parse name
+        put '$' if proxied
       else
         parse name
+        put '$' if proxied
         put ' = class'
       end
 
@@ -24,11 +35,6 @@ module Ruby2JS
 
       put " {"
 
-      body.compact!
-      while body.length == 1 and body.first.type == :begin
-        body = body.first.children 
-      end
-
       begin
         class_name, @class_name = @class_name, name
         class_parent, @class_parent = @class_parent, inheritance
@@ -64,21 +70,21 @@ module Ruby2JS
               walk[child] if child.is_a? Parser::AST::Node
             end
 
-	    if ast.type == :send and ast.children.first == nil
-	      if ast.children[1] == :attr_accessor
-		ast.children[2..-1].each_with_index do |child_sym, index2|
-		  ivars << :"@#{child_sym.children.first}"
-		end
-	      elsif ast.children[1] == :attr_reader
-		ast.children[2..-1].each_with_index do |child_sym, index2|
-		  ivars << :"@#{child_sym.children.first}"
-		end
-	      elsif ast.children[1] == :attr_writer
-		ast.children[2..-1].each_with_index do |child_sym, index2|
-		  ivars << :"@#{child_sym.children.first}"
-		end
-	      end
-	    end
+            if ast.type == :send and ast.children.first == nil
+              if ast.children[1] == :attr_accessor
+                ast.children[2..-1].each_with_index do |child_sym, index2|
+                  ivars << :"@#{child_sym.children.first}"
+                end
+              elsif ast.children[1] == :attr_reader
+                ast.children[2..-1].each_with_index do |child_sym, index2|
+                  ivars << :"@#{child_sym.children.first}"
+                end
+              elsif ast.children[1] == :attr_writer
+                ast.children[2..-1].each_with_index do |child_sym, index2|
+                  ivars << :"@#{child_sym.children.first}"
+                end
+              end
+            end
 
           end
           walk[@ast]
@@ -299,6 +305,43 @@ module Ruby2JS
           end
         end
 
+        if proxied
+          put @sep
+
+          rename = name.updated(nil, [name.children.first, name.children.last.to_s + '$'])
+
+          if proxied.children[1].children.length == 1
+            # special case: if method_missing only has on argument, call it
+            # directly (i.e., don't pass arguments).  This enables
+            # method_missing to return instance attributes (getters) as well
+            # as bound functions (methods).
+            forward = s(:send, s(:lvar, :obj), :method_missing, s(:lvar, :prop))
+          else
+            # normal case: return a function which, when called, will call
+            # method_missing with method name and arguments.
+            forward = s(:block, s(:send, nil, :proc), s(:args, s(:restarg, :args)),
+            s(:send, s(:lvar, :obj), :method_missing, s(:lvar, :prop),
+            s(:splat, s(:lvar, :args))))
+          end
+
+          proxy = s(:return, s(:send, s(:const, nil, :Proxy), :new,
+            s(:send, rename, :new, s(:splat, s(:lvar, :args))),
+            s(:hash, s(:pair, s(:sym, :get), s(:block, s(:send, nil, :proc),
+            s(:args, s(:arg, :obj), s(:arg, :prop)),
+            s(:if, s(:in?, s(:lvar, :prop), s(:lvar, :obj)),
+            s(:return, s(:send, s(:lvar, :obj), :[], s(:lvar, :prop))),
+            s(:return, forward))))))
+          )
+
+          if name.children.first == nil
+            proxy = s(:def, name.children.last, s(:args, s(:restarg, :args)), proxy)
+          else
+            proxy = s(:defs, *name.children, s(:args, s(:restarg, :args)), proxy)
+          end
+
+          parse proxy
+        end
+
       ensure
         @class_name = class_name
         @class_parent = class_parent

data/lib/ruby2js/converter/def.rb

@@ -131,7 +131,7 @@ module Ruby2JS
           style = :statement
         end
 
-        if args.children.length == 1 and style == :expression
+        if args.children.length == 1 and args.children.first.type != :restarg and style == :expression
           parse args; put ' => '
         else
           put '('; parse args; put ') => '

data/lib/ruby2js/converter/import.rb

@@ -82,7 +82,7 @@ module Ruby2JS
       elsif node.respond_to?(:type) && node.children[1] == :default
         put 'default '
         args[0] = node.children[2]
-      elsif node.respond_to?(:type) && node.type == :lvasgn
+      elsif node.respond_to?(:type) && [:lvasgn, :casgn].include?(node.type)
         if node.children[0] == :default
           put 'default '
           args[0] = node.children[1]

data/lib/ruby2js/converter/literal.rb

@@ -5,12 +5,24 @@ module Ruby2JS
     # (float 1.1)
     # (str "1"))
 
-    handle :int, :float, :str do |value|
+    handle :str do |value|
       put value.inspect
     end
 
+    handle :int, :float do |value|
+      put number_format(value)
+    end
+
     handle :octal do |value|
-      put '0' + value.to_s(8)
+      put '0' + number_format(value.to_s(8))
+    end
+
+    def number_format(number)
+      return number.to_s unless es2021
+      parts = number.to_s.split('.')
+      parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1_")
+      parts[1].gsub!(/(\d\d\d)(?=\d)/, "\\1_") if parts[1]
+      parts.join('.')
     end
   end
 end

data/lib/ruby2js/converter/send.rb

@@ -9,11 +9,12 @@ module Ruby2JS
     # (sendw nil :puts
     #   (int 1))
 
-    # Note: attr, sendw, and await are only generated by filters.  Attr forces
+    # Note: attr, sendw, send!, and await are only generated by filters.  Attr forces
     # interpretation as an attribute vs a function call with zero parameters.
+    # send! forces interpretation as a method call even with zero parameters.
     # Sendw forces parameters to be placed on separate lines.
 
-    handle :send, :sendw, :await, :attr, :call do |receiver, method, *args|
+    handle :send, :sendw, :send!, :await, :attr, :call do |receiver, method, *args|
       ast = @ast
 
       if \
@@ -280,7 +281,7 @@ module Ruby2JS
       else
         put 'await ' if @ast.type == :await
 
-        if not ast.is_method?
+        if not ast.is_method? and ast.type != :send!
           if receiver
             (group_receiver ? group(receiver) : parse(receiver))
             put ".#{ method }"

data/lib/ruby2js/converter/xstr.rb

@@ -10,7 +10,7 @@ module Ruby2JS
       if @binding
         puts @binding.eval(str).to_s
       else
-        puts eval(str).to_s
+        raise SecurityError.new('Insecure operation, eval without binding option')
       end
     end
   end

data/lib/ruby2js/filter/active_functions.rb

@@ -0,0 +1,43 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module ActiveFunctions
+      include SEXP
+
+      def on_send(node)
+        target, method, *args = node.children
+
+        if es2015 and method == :blank?
+          create_or_update_import("blank$")
+          process node.updated :send, [nil, "blank$", target]
+        elsif es2015 and method == :present?
+          create_or_update_import("present$")
+          process node.updated :send, [nil, "present$", target]
+        elsif es2015 and method == :presence
+          create_or_update_import("presence$")
+          process node.updated :send, [nil, "presence$", target]
+        else
+          super
+        end
+      end
+
+      private
+
+      def create_or_update_import(token)
+        af_import = @options[:import_from_skypack] ? "https://cdn.skypack.dev/@ruby2js/active-functions" : "@ruby2js/active-functions"
+
+        if found_node = prepend_list.find {|ast| ast.type == :import && ast.children.first == af_import}
+          unless found_node.children.find {|child| child == token}
+            prepend_list.delete found_node
+            prepend_list << s(:import, found_node.children.first, found_node.children.last.push(s(:const, nil, token)))
+          end
+        else
+          prepend_list << s(:import, af_import, [s(:const, nil, token)])
+        end
+      end
+    end
+
+    DEFAULTS.push ActiveFunctions
+  end
+end

data/lib/ruby2js/filter/camelCase.rb

@@ -9,8 +9,9 @@ module Ruby2JS
     module CamelCase
       include SEXP
 
-      WHITELIST = %w{
+      ALLOWLIST = %w{
         attr_accessor
+        method_missing
       }
 
       CAPS_EXCEPTIONS = {
@@ -37,7 +38,7 @@ module Ruby2JS
         node = super
         return node unless [:send, :csend, :attr].include? node.type
 
-        if node.children[0] == nil and WHITELIST.include? node.children[1].to_s
+        if node.children[0] == nil and ALLOWLIST.include? node.children[1].to_s
           node
         elsif node.children[0] && [:ivar, :cvar].include?(node.children[0].type)
           S(node.type, s(node.children[0].type, camelCase(node.children[0].children[0])),
@@ -61,7 +62,7 @@ module Ruby2JS
       def handle_generic_node(node, node_type)
         return node if node.type != node_type
 
-        if node.children[0] =~ /_.*\w$/
+        if node.children[0] =~ /_.*\w$/ and !ALLOWLIST.include?(node.children[0].to_s)
           S(node_type , camelCase(node.children[0]), *node.children[1..-1])
         else
           node

data/lib/ruby2js/filter/esm.rb

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

data/lib/ruby2js/filter/functions.rb

@@ -540,6 +540,11 @@ module Ruby2JS
         elsif method == :floor and args.length == 0
           process S(:send, s(:const, nil, :Math), :floor, target)
 
+        elsif method == :sum and args.length == 0
+          process S(:send, target, :reduce, s(:block, s(:send, nil, :proc),
+            s(:args, s(:arg, :a), s(:arg, :b)),
+            s(:send, s(:lvar, :a), :+, s(:lvar, :b))), s(:int, 0))
+
         else
           super
         end

data/lib/ruby2js/filter/node.rb

@@ -14,6 +14,10 @@ module Ruby2JS
 
       IMPORT_FS = s(:import, ['fs'], s(:attr, nil, :fs))
 
+      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)))
 
@@ -31,11 +35,11 @@ module Ruby2JS
             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
@@ -57,7 +61,7 @@ module Ruby2JS
         then
           if method == :read and args.length == 1
             prepend_list << IMPORT_FS
-            s(:send, s(:attr, nil, :fs), :readFileSync, *process_all(args),
+            S(:send, s(:attr, nil, :fs), :readFileSync, *process_all(args),
               s(:str, 'utf8'))
 
           elsif method == :write and args.length == 2
@@ -111,15 +115,15 @@ module Ruby2JS
             
           elsif method == :symlink and args.length == 2
             prepend_list << IMPORT_FS
-            s(:send, s(:attr, nil, :fs), :symlinkSync, *process_all(args))
+            S(:send, s(:attr, nil, :fs), :symlinkSync, *process_all(args))
             
           elsif method == :truncate and args.length == 2
             prepend_list << IMPORT_FS
-            s(:send, s(:attr, nil, :fs), :truncateSync, *process_all(args))
+            S(:send, s(:attr, nil, :fs), :truncateSync, *process_all(args))
             
           elsif [:stat, :lstat].include? method and args.length == 1
             prepend_list << IMPORT_FS
-            s(:send, s(:attr, nil, :fs), method.to_s + 'Sync',
+            S(:send, s(:attr, nil, :fs), method.to_s + 'Sync',
               process(args.first))
 
           elsif method == :unlink and args.length == 1
@@ -128,6 +132,29 @@ module Ruby2JS
               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
@@ -163,7 +190,7 @@ 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
             prepend_list << IMPORT_FS
@@ -173,11 +200,11 @@ module Ruby2JS
 
           elsif method == :ln and args.length == 2
             prepend_list << IMPORT_FS
-            s(:send, s(:attr, nil, :fs), :linkSync, *process_all(args))
+            S(:send, s(:attr, nil, :fs), :linkSync, *process_all(args))
             
           elsif method == :ln_s and args.length == 2
             prepend_list << IMPORT_FS
-            s(:send, s(:attr, nil, :fs), :symlinkSync, *process_all(args))
+            S(:send, s(:attr, nil, :fs), :symlinkSync, *process_all(args))
             
           elsif method == :rm and args.length == 1
             prepend_list << IMPORT_FS
@@ -224,16 +251,16 @@ 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
             prepend_list << IMPORT_FS
-            s(:send, s(:attr, nil, :fs), :readdirSync, *process_all(args))
+            S(:send, s(:attr, nil, :fs), :readdirSync, *process_all(args))
           elsif method == :mkdir and args.length == 1
             prepend_list << IMPORT_FS
-            s(:send, s(:attr, nil, :fs), :mkdirSync, process(args.first))
+            S(:send, s(:attr, nil, :fs), :mkdirSync, process(args.first))
           elsif method == :rmdir and args.length == 1
             prepend_list << IMPORT_FS
-            s(:send, s(:attr, nil, :fs), :rmdirSync, process(args.first))
+            S(:send, s(:attr, nil, :fs), :rmdirSync, process(args.first))
           elsif method == :mktmpdir and args.length <=1
             prepend_list << IMPORT_FS
             if args.length == 0
@@ -244,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
@@ -285,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

data/lib/ruby2js/serializer.rb

@@ -42,6 +42,7 @@ module Ruby2JS
 
   class Serializer
     attr_reader :timestamps
+    attr_accessor :file_name
 
     def initialize
       @sep = '; '
@@ -56,6 +57,7 @@ module Ruby2JS
       @timestamps = {}
 
       @ast = nil
+      @file_name = ''
     end
 
     def timestamp(file)
@@ -363,7 +365,7 @@ module Ruby2JS
 
       @sourcemap = {
         version: 3,
-        file: @ast.loc.expression.source_buffer.name,
+        file: @file_name,
         sources: sources.map(&:name),
         mappings: @mappings
       }

data/lib/ruby2js/version.rb

@@ -1,8 +1,8 @@
 module Ruby2JS
   module VERSION #:nodoc:
     MAJOR = 3
-    MINOR = 5
-    TINY  = 3
+    MINOR = 6
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/ruby2js.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
-  s.authors = ["Sam Ruby".freeze]
+  s.authors = ["Sam Ruby".freeze, "Jared White".freeze]
   s.description = "    The base package maps Ruby syntax to JavaScript semantics.\n    Filters may be provided to add Ruby-specific or framework specific\n    behavior.\n".freeze
   s.email = "rubys@intertwingly.net".freeze
   s.files = %w(ruby2js.gemspec README.md) + Dir.glob("{lib}/**/*")

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ruby2js
 version: !ruby/object:Gem::Version
-  version: 3.5.3
+  version: 3.6.0
 platform: ruby
 authors:
 - Sam Ruby
-autorequire:
+- Jared White
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-24 00:00:00.000000000 Z
+date: 2020-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -121,10 +122,10 @@ files:
 - lib/ruby2js/es2021/strict.rb
 - lib/ruby2js/execjs.rb
 - lib/ruby2js/filter.rb
+- lib/ruby2js/filter/active_functions.rb
 - lib/ruby2js/filter/camelCase.rb
 - lib/ruby2js/filter/cjs.rb
 - lib/ruby2js/filter/esm.rb
-- lib/ruby2js/filter/esm_migration.rb
 - lib/ruby2js/filter/functions.rb
 - lib/ruby2js/filter/jquery.rb
 - lib/ruby2js/filter/matchAll.rb
@@ -150,7 +151,7 @@ homepage: http://github.com/rubys/ruby2js
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -165,8 +166,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.0.rc.1
-signing_key:
+rubygems_version: 3.1.4
+signing_key: 
 specification_version: 4
 summary: Minimal yet extensible Ruby to JavaScript conversion.
 test_files: []

data/lib/ruby2js/filter/esm_migration.rb

@@ -1,72 +0,0 @@
-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