ruby2js 3.4.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df66ef5836777a349c4f702cb4482631c3260f95f82d2f292ae914dfc9de5d86
-  data.tar.gz: 6d4d513cdc4130c3e2a1af390441fd8e0642dd74b331498e4ab60799965c072b
+  metadata.gz: 7fa9e6949c8d7d1f3f5cb549dc234a2b559d032bc9b5b236d123f68b62ecd763
+  data.tar.gz: e89542553f4db3caa7ceda112542a3a7fceb468d23d8a15cb9b416954c054d1f
 SHA512:
-  metadata.gz: b6b1f96c9e312700bd774f1d6344c21f67c48da1a9fea50f927ade02910541c56aa31fab988bd9a9e16a136e7112cbc830bfdda80bfa6486f5015e9a2edcf360
-  data.tar.gz: 4b151db4cfe119e206ef46ac89b870754a531e67cf6b6026aec4d1639563220079db3d37d3b95e2070bb8d0c4f8bfdeead16bcb76f10d2a593d6fa4b7de224b3
+  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
@@ -81,6 +78,18 @@ require 'ruby2js/filter/functions'
 puts Ruby2JS.convert('"2A".to_i(16)')
 ```
 
+Host variable substitution:
+
+```ruby
+ 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
@@ -129,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:
@@ -144,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).
 
@@ -169,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`
@@ -192,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
 ---
@@ -237,8 +244,10 @@ the script.
 
 * <a id="functions" href="https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/filter/functions.rb">functions</a>
 
+    * `.abs` becomes `Math.abs()`
     * `.all?` becomes `.every`
     * `.any?` becomes `.some`
+    * `.ceil` becomes `Math.ceil()`
     * `.chr` becomes `fromCharCode`
     * `.clear` becomes `.length = 0`
     * `.delete` becomes `delete target[arg]`
@@ -253,6 +262,7 @@ the script.
     * `.find_index` becomes `findIndex`
     * `.first` becomes `[0]`
     * `.first(n)` becomes `.slice(0, n)`
+    * `.floor` becomes `Math.floor()`
     * `.gsub` becomes `replace(//g)`
     * `.include?` becomes `.indexOf() != -1`
     * `.inspect` becomes `JSON.stringify()`
@@ -271,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)`
@@ -317,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
@@ -382,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"})`
@@ -389,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`
@@ -600,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
 ---
@@ -610,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
@@ -620,7 +719,15 @@ 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:
+
+* `async def` becomes `async function`
+* `async lambda` becomes `async =>`
+* `async proc` becomes `async =>`
+* `async ->` becomes `async =>`
+* `foo bar, async do...end` becomes `foo(bar, async () => {})`
 
 ES2018 support
 ---
@@ -640,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)`
 
@@ -667,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

@@ -17,6 +17,7 @@ module Ruby2JS
 
   @@eslevel_default = 2009 # ecmascript 5
   @@strict_default = false
+  @@module_default = nil
 
   def self.eslevel_default
     @@eslevel_default
@@ -34,6 +35,14 @@ module Ruby2JS
     @@strict_default = level
   end
 
+  def self.module_default
+    @@module_default
+  end
+
+  def self.module_default=(module_type)
+    @@module_default = module_type
+  end
+
   module Filter
     DEFAULTS = []
 
@@ -52,11 +61,19 @@ module Ruby2JS
       include Ruby2JS::Filter
       BINARY_OPERATORS = Converter::OPERATORS[2..-1].flatten
 
+      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
 
       def options=(options)
@@ -129,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
@@ -162,6 +180,7 @@ module Ruby2JS
   def self.convert(source, options={})
     options[:eslevel] ||= @@eslevel_default
     options[:strict] = @@strict_default if options[:strict] == nil
+    options[:module] ||= @@module_default || :esm
 
     if Proc === source
       file,line = source.source_location
@@ -175,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)
@@ -193,6 +212,12 @@ module Ruby2JS
 
       filter.options = options
       ast = filter.process(ast)
+
+      unless filter.prepend_list.empty?
+        prepend = filter.prepend_list.sort_by {|ast| ast.type == :import ? 0 : 1}
+        prepend.reject! {|ast| ast.type == :import} if filter.disable_autoimports
+        ast = Parser::AST::Node.new(:begin, [*prepend, ast])
+      end
     end
 
     ruby2js = Ruby2JS::Converter.new(ast, comments)
@@ -203,6 +228,7 @@ module Ruby2JS
     ruby2js.strict = options[:strict]
     ruby2js.comparison = options[:comparison] || :equality
     ruby2js.or = options[:or] || :logical
+    ruby2js.module_type = options[:module] || :esm
     ruby2js.underscored_private = (options[:eslevel] < 2020) || options[:underscored_private]
     if ruby2js.binding and not ruby2js.ivars
       ruby2js.ivars = ruby2js.binding.eval \
@@ -221,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

@@ -3,9 +3,11 @@ require 'ruby2js/serializer'
 module Ruby2JS
   class Error < NotImplementedError
     def initialize(message, ast)
-      message += ' at ' + ast.loc.expression.source_buffer.name.to_s
-      message += ':' + ast.loc.expression.line.inspect
-      message += ':' + ast.loc.expression.column.to_s
+      if ast.loc
+        message += ' at ' + ast.loc.expression.source_buffer.name.to_s
+        message += ':' + ast.loc.expression.line.inspect
+        message += ':' + ast.loc.expression.column.to_s
+      end
       super(message)
     end
   end
@@ -128,7 +130,7 @@ module Ruby2JS
       Parser::AST::Node.new(type, args)
     end
 
-    attr_accessor :strict, :eslevel, :comparison, :or, :underscored_private
+    attr_accessor :strict, :eslevel, :module_type, :comparison, :or, :underscored_private
 
     def es2015
       @eslevel >= 2015
@@ -246,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/block.rb

@@ -9,6 +9,11 @@ module Ruby2JS
 
     handle :block do |call, args, block|
 
+      if es2017 and call.children.last == s(:send, nil, :async)
+        return parse call.updated(nil, [*call.children[0..-2],
+        s(:send, nil, :async, s(:block, s(:send, nil, :proc), args, block))])
+      end
+
       if \
         @state == :statement and args.children.length == 1 and
         call.children.first and call.children.first.type == :begin and