ruby2js 3.3.3 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a14485c0400fde35f0734d3e237f2b2d7fdda41377c9d26aeede802634a619e4
-  data.tar.gz: 3f27f9ac6e92ab7a67823361dfea1b42b09c9dd405dfd7855e278114b3dfccfa
+  metadata.gz: 2cdffdc5d823c8e1c36abf924de9f8a489508a5c472b5ac0dd11c42f14dfa7e1
+  data.tar.gz: bfa2a41e9865fef31f7502ab1027f5486103434050aec92d3fe4d6044d165d52
 SHA512:
-  metadata.gz: '0953480e1e37ebf92fd62af8a55ef77c203c42b2a4ca2880d623a573feadc5b294319cac53f48f36dc5564f4420425cd238dccf3b4cb2a07aab31b7c474cbb9a'
-  data.tar.gz: 600d4fcd56f5da3144a3f48d872bfdd9293e3de233b47b6b3fb5473a4424e1d4db55b59fef9a59f96df2ba82978dea52b6cb0c070929867a89ce2fa0ea170291
+  metadata.gz: ce19f04471f515a27d5cd13fb8beea734fb88246efe03a7ac746e29b07a96696afc5751de9d5f73f0d81d761de7bd8d853197e7d0ce7ce68eab0796524f2b222
+  data.tar.gz: 70080cf83c65cfe8d8c6aaa6067ae191df714dfe838977e5be50902624f4e516a680ee0459fcdd8d7274834e29841df5ec592e6ee31dfe990dea305f457c1707

data/README.md

@@ -5,6 +5,7 @@ Minimal yet extensible Ruby to JavaScript conversion.
 
 [![Build Status](https://travis-ci.org/rubys/ruby2js.svg)](https://travis-ci.org/rubys/ruby2js)
 [![Gem Version](https://badge.fury.io/rb/ruby2js.svg)](https://badge.fury.io/rb/ruby2js)
+[![Gitter](https://badges.gitter.im/ruby2js/community.svg)](https://gitter.im/ruby2js/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 
 Description
 ---
@@ -104,6 +105,13 @@ Emit nullish coalescing operators:
 puts Ruby2JS.convert('a || 1', or: :nullish)
 ```
 
+Emit underscored private fields (allowing subclass access):
+
+```ruby
+puts Ruby2JS.convert('class C; def initialize; @f=1; end; end',
+  eslevel: 2020, underscored_private: true)
+```
+
 With [ExecJS](https://github.com/sstephenson/execjs):
 ```ruby
 require 'ruby2js/execjs'
@@ -193,7 +201,7 @@ Integrations
 
 While this is a low level library suitable for DIY integration, one of the
 obvious uses of a tool that produces JavaScript is by web servers.  Ruby2JS
-includes three such integrations:
+includes several integrations:
 
 *  [CGI](https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/cgi.rb)
 *  [Sinatra](https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/sinatra.rb)
@@ -204,6 +212,9 @@ As you might expect, CGI is a bit sluggish.  By contrast, Sinatra and Rails
 are quite speedy as the bulk of the time is spent on the initial load of the
 required libraries.
 
+For easy integration with Webpack (and Webpacker in Rails 5+), you can use the
+[rb2js-loader](https://github.com/whitefusionhq/rb2js-loader) plugin.
+
 Filters
 ---
 
@@ -270,10 +281,12 @@ the script.
     * `(b...a).to_a` becomes `Array.apply(null, {length: (a-b)}).map(Function.call, Number).map(function (idx) { return idx+b })`
     * `.strip` becomes `.trim`
     * `.sub` becomes `.replace`
+    * `.tap {|n| n}` becomes `(function(n) {n; return n})(...)`
     * `.to_f` becomes `parseFloat`
     * `.to_i` becomes `parseInt`
     * `.to_s` becomes `.to_String`
     * `.upcase` becomes `.toUpperCase`
+    * `.yield_self {|n| n}` becomes `(function(n) {return n})(...)`
     * `[-n]` becomes `[*.length-n]` for literal values of `n`
     * `[n...m]` becomes `.slice(n,m)`
     * `[n..m]` becomes `.slice(n,m+1)`
@@ -297,12 +310,78 @@ the script.
       of `Error` instead; and default constructors will be provided
     * `loop do...end` will be replaced with `while (true) {...}`
     * `raise Exception.new(...)` will be replaced with `throw new Error(...)`
+    * `block_given?` will check for the presence of optional argument `_implicitBlockYield` which is a function made accessible through the use of `yield` in a method body.
 
     Additionally, there is one mapping that will only be done if explicitly
-    <a href="https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/filter.rb">included</a>:
+    included (pass `include: :class` as a `convert` option to enable):
 
     * `.class` becomes `.constructor`
 
+* <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
+    template literals. By default it supports html and css, so you can write
+    `html "<div>#{1+2}</div>"` which converts to `` html`<div>${1+2}</div>` ``.
+    Works nicely with squiggly heredocs for multi-line templates as well. If you
+    need to configure the tag names yourself, pass a `template_literal_tags`
+    option to `convert` with an array of tag name symbols.
+
+    Note: these conversions are only done if eslevel >= 2015
+
+* <a href="https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/filter/esm.rb">esm</a>
+
+    Provides conversion of import and export statements for use with modern ES builders like Webpack.
+
+    Examples:
+
+    **import**
+
+    ```ruby
+    import "./index.scss"
+    # => import "./index.scss"
+
+    import Something from "./lib/something"
+    # => import Something from "./lib/something"
+
+    import Something, "./lib/something"
+    # => import Something from "./lib/something"
+
+    import [ LitElement, html, css ], from: "lit-element"
+    # => import { LitElement, html, css } from "lit-element"
+
+    import React, from: "react"
+    # => import React from "react"
+
+    import React, as: "*", from: "react"
+    # => import React as * from "react"
+    ```
+
+    **export**
+
+    ```ruby
+    export hash = { ab: 123 }
+    # => export const hash = {ab: 123};
+
+    export func = ->(x) { x * 10 }
+    # => export const func = x => x * 10;
+
+    export def multiply(x, y)
+      return x * y
+    end
+    # => export function multiply(x, y) {
+    #      return x * y
+    #    }
+
+    export default class MyClass
+    end
+    # => export default class MyClass {
+    #    };
+
+    # or final export statement:
+    export [ one, two, default: three ]
+    # => export { one, two, three as default }
+    ```
+
 * <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"})`
@@ -388,68 +467,6 @@ the script.
     * `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()`
-    * `.capitalize()` becomes `_s.capitalize()`
-    * `.center()` becomes `_s.center()`
-    * `.chomp()` becomes `_s.chomp()`
-    * `.collect_concat()` becomes `_e.collect_concat()`
-    * `.compact()` becomes `_a.compact()`
-    * `.compact!()` becomes `_a.compact_bang()`
-    * `.count()` becomes `_e.count()`
-    * `.cycle()` becomes `_e.cycle()`
-    * `.delete_at()` becomes `_a.delete_at()`
-    * `.delete_if()` becomes `_a.delete_if()`
-    * `.drop_while()` becomes `_e.drop_while()`
-    * `.each_index()` becomes `_e.each_index()`
-    * `.each_slice()` becomes `_e.each_slice()`
-    * `.each_with_index()` becomes `_e.each_with_index()`
-    * `.each_with_object()` becomes `_e.each_with_object()`
-    * `.find_all()` becomes `_e.find_all()`
-    * `.find()` becomes `_e.find()`
-    * `.flat_map()` becomes `_e.flat_map()`
-    * `.flatten()` becomes `_a.flatten()`
-    * `.grep()` becomes `_e.grep()`
-    * `.group_by()` becomes `_e.group_by()`
-    * `.inject()` becomes `_e.inject()`
-    * `.insert()` becomes `_a.insert()`
-    * `.keep_if()` becomes `_a.keep_if()`
-    * `.ljust()` becomes `_s.ljust()`
-    * `.lstrip()` becomes `_s.lstrip()`
-    * `.map()` becomes `_e.map()`
-    * `.max_by()` becomes `_e.max_by()`
-    * `.min_by()` becomes `_e.min_by()`
-    * `.one?()` becomes `_e.one()`
-    * `.partition()` becomes `_e.partition()`
-    * `.reject()` becomes `_e.reject()`
-    * `.reverse()` becomes `_a.reverse()`
-    * `.reverse!()` becomes `_a.reverse_bang()`
-    * `.reverse_each()` becomes `_e.reverse_each()`
-    * `.rindex()` becomes `_s.rindex()`
-    * `.rjust()` becomes `_s.rjust()`
-    * `.rotate()` becomes `_a.rotate()`
-    * `.rotate!()` becomes `_a.rotate_bang()`
-    * `.rstrip()` becomes `_s.rstrip()`
-    * `.scan()` becomes `_s.scan()`
-    * `.select()` becomes `_a.select()`
-    * `.shift()` becomes `_a.shift()`
-    * `.shuffle()` becomes `_a.shuffle()`
-    * `.shuffle!()` becomes `_a.shuffle_bang()`
-    * `.slice()` becomes `_a.slice()`
-    * `.slice!()` becomes `_a.slice_bang()`
-    * `.sort_by()` becomes `_e.sort_by()`
-    * `.strftime()` becomes `_t.strftime()`
-    * `.swapcase()` becomes `_s.swapcase()`
-    * `.take_while()` becomes `_e.take_while(`)
-    * `.transpose()` becomes `_a.transpose()`
-    * `.tr()` becomes `_s.tr()`
-    * `.union()` becomes `_a.union()`
-    * `.uniq()` becomes `_a.uniq()`
-    * `.uniq!()` becomes `_a.uniq_bang()`
-    * `<=>` becomes `R.Comparable.cmp()`
-    * `(n..m)` becomes `R.Range.new()`
-
 * <a id="underscore" href="https://github.com/rubys/ruby2js/blob/master/spec/underscore.rb">underscore</a>
 
     * `.clone()` becomes `_.clone()`
@@ -605,6 +622,14 @@ conversions are made by the `functions` filter:
 * `.entries()` becomes `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
 ---
 
@@ -677,7 +702,7 @@ License
 
 (The MIT License)
 
-Copyright (c) 2009, 2013 Macario Ortega, Sam Ruby
+Copyright (c) 2009, 2020 Macario Ortega, Sam Ruby, Jared White
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/ruby2js.rb

@@ -56,6 +56,7 @@ module Ruby2JS
         @comments = comments
         @ast = nil
         @exclude_methods = []
+        @esm = false
       end
 
       def options=(options)
@@ -134,6 +135,7 @@ module Ruby2JS
       def on_xnode(node); end
       def on_export(node); end
       def on_import(node); end
+      def on_taglit(node); end
 
       # provide a method so filters can call 'super'
       def on_sym(node); node; end
@@ -201,6 +203,7 @@ module Ruby2JS
     ruby2js.strict = options[:strict]
     ruby2js.comparison = options[:comparison] || :equality
     ruby2js.or = options[:or] || :logical
+    ruby2js.underscored_private = (options[:eslevel] < 2020) || options[:underscored_private]
     if ruby2js.binding and not ruby2js.ivars
       ruby2js.ivars = ruby2js.binding.eval \
         'Hash[instance_variables.map {|var| [var, instance_variable_get(var)]}]'

data/lib/ruby2js/converter.rb

@@ -63,6 +63,7 @@ module Ruby2JS
       @strict = false
       @comparison = :equality
       @or = :logical
+      @underscored_private = true
     end
 
     def width=(width)
@@ -127,7 +128,7 @@ module Ruby2JS
       Parser::AST::Node.new(type, args)
     end
 
-    attr_accessor :strict, :eslevel, :comparison, :or
+    attr_accessor :strict, :eslevel, :comparison, :or, :underscored_private
 
     def es2015
       @eslevel >= 2015
@@ -332,6 +333,7 @@ require 'ruby2js/converter/self'
 require 'ruby2js/converter/send'
 require 'ruby2js/converter/super'
 require 'ruby2js/converter/sym'
+require 'ruby2js/converter/taglit'
 require 'ruby2js/converter/undef'
 require 'ruby2js/converter/until'
 require 'ruby2js/converter/untilpost'
@@ -341,3 +343,4 @@ require 'ruby2js/converter/while'
 require 'ruby2js/converter/whilepost'
 require 'ruby2js/converter/xstr'
 require 'ruby2js/converter/xnode'
+require 'ruby2js/converter/yield'

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

data/lib/ruby2js/converter/class2.rb

@@ -49,7 +49,7 @@ module Ruby2JS
         end
 
         # private variable declarations
-        if es2020
+        unless underscored_private
           ivars = Set.new
           cvars = Set.new
 
@@ -202,7 +202,7 @@ module Ruby2JS
             end
 
           elsif m.type == :send and m.children.first == nil
-            p = es2020 ? '#' : '_'
+            p = underscored_private ? '_' : '#'
 
             if m.children[1] == :attr_accessor
               m.children[2..-1].each_with_index do |child_sym, index2|
@@ -236,7 +236,7 @@ module Ruby2JS
             end
 
           else
-            if m.type == :cvasgn and es2020
+            if m.type == :cvasgn and !underscored_private
               put 'static #$'; put m.children[0].to_s[2..-1]; put ' = '
               parse m.children[1]
             else
@@ -288,6 +288,12 @@ module Ruby2JS
                 [name, innerclass_name.children[1]])
             end
             parse m.updated(nil, [innerclass_name, *m.children[1..-1]])
+          elsif m.type == :send && (m.children[0].nil? || m.children[0].type == :self)
+            if m.children[0].nil?
+              parse m.updated(:send, [@class_name, *m.children[1..-1]])
+            else
+              parse m.updated(:send, [@class_name, *m.children[1..-1]])
+            end
           else
             parse m, :statement
           end

data/lib/ruby2js/converter/cvar.rb

@@ -4,7 +4,7 @@ module Ruby2JS
     # (cvar :@@a)
 
     handle :cvar do |var|
-      prefix = es2020 ? '#$' : '_'
+      prefix = underscored_private ? '_' : '#$'
 
       @class_name ||= nil
       if @class_name

data/lib/ruby2js/converter/cvasgn.rb

@@ -7,7 +7,7 @@ module Ruby2JS
     handle :cvasgn do |var, expression=nil|
       multi_assign_declarations if @state == :statement
 
-      prefix = es2020 ? '#$' : '_'
+      prefix = underscored_private ? '_' : '#$'
 
       if @class_name
         parse @class_name

data/lib/ruby2js/converter/def.rb

@@ -9,6 +9,22 @@ module Ruby2JS
     handle :def, :defm, :async do |name, args, body=nil|
       body ||= s(:begin)
 
+      add_implicit_block = false
+
+      walk = ->(node) do
+        add_implicit_block = true if node.type == :yield || (node.type == :send && node.children[1] == "_implicitBlockYield")
+        node.children.each do |child|
+          walk[child] if child.is_a? Parser::AST::Node
+        end
+      end
+      walk[body]
+
+      if add_implicit_block
+        children = args.children.dup
+        children.push s(:optarg, "_implicitBlockYield", s(:nil))
+        args = s(:args, *children)
+      end
+
       vars = {}
       vars.merge! @vars unless name
       if args and !args.children.empty?

data/lib/ruby2js/converter/dstr.rb

@@ -20,7 +20,7 @@ module Ruby2JS
         put '`'
         children.each do |child|
           if child.type == :str
-            str = child.children.first.inspect[1..-2].gsub('${', '$\{')
+            str = child.children.first.inspect[1..-2].gsub('${', '$\{').gsub('`', '\\\`')
             if heredoc
               put! str.gsub("\\n", "\n")
             else

data/lib/ruby2js/converter/hash.rb

@@ -97,9 +97,19 @@ module Ruby2JS
                 end
 
                 # use fat arrow syntax if block contains a reference to 'this'
-                if anonfn
+                if anonfn and @class_name
                   walk = proc do |ast|
-                    anonfn = false if ast == s(:send, nil, :this)
+                    if ast == s(:self)
+                      anonfn = false
+                    elsif [:ivar, :ivasgn].include? ast.type
+                      anonfn = false
+                    elsif ast.type == :send and ast.children.first == nil 
+                      method = ast.children.last if ast.children.length == 2
+                      if @rbstack.any? {|rb| rb[method]} or method == :this
+                        anonfn = false
+                      end
+                    end
+
                     ast.children.each do |child|
                       walk[child] if child.is_a? Parser::AST::Node
                     end

data/lib/ruby2js/converter/import.rb

@@ -7,14 +7,47 @@ module Ruby2JS
 
     handle :import do |path, *args|
       put 'import '
+      if args.length == 0
+        # import "file.css"
+        put path.inspect
+      else
+        # import (x) from "file.js"
+        default_import = !args.first.is_a?(Array) && [:const, :send, :attr].include?(args.first.type)
+        args = args.first if args.first.is_a?(Array)
 
-      args.each_with_index do |arg, index|
-        put ', ' unless index == 0
-        parse arg
-      end
+        # handle the default name or { ConstA, Const B } portion
+        put "{ " unless default_import
+        args.each_with_index do |arg, index|
+          put ', ' unless index == 0
+          parse arg
+        end
+        put " }" unless default_import
+
+        from_kwarg_position = 0
+
+        # should there be an as clause? e.g., import React as *
+        if path.is_a?(Array) && !path[0].is_a?(String) && path[0].type == :pair && path[0].children[0].children[0] == :as
+          put " as #{path[0].children[1].children[0]}"
+
+          # advance to the next kwarg, aka from
+          from_kwarg_position = 1
+        end
 
-      put ' from '
-      put path.inspect
+        put ' from '
+
+        if path.is_a?(Array) && !path[from_kwarg_position].is_a?(String) && path[from_kwarg_position].type == :pair
+          # from: "str" => from "str"
+          if path[from_kwarg_position].children[0].children[0] == :from
+            put path[from_kwarg_position].children[1].children[0].inspect
+          else
+            # from is missing
+            put '""'
+          end
+        else
+          # handle a str in either an array element or directly passed in
+          put path.is_a?(Array) ? path[0].inspect : path.inspect
+        end
+      end
     end
 
     # (export const) 
@@ -24,14 +57,49 @@ module Ruby2JS
     handle :export do |*args|
       put 'export '
 
-      if args.first == :default
+      node = args.first
+      final_export = false
+
+      if node == :default
         put 'default '
         args.shift
+      elsif node.respond_to?(:type) && node.children[1] == :default
+        put 'default '
+        args[0] = node.children[2]
+      elsif node.respond_to?(:type) && node.type == :lvasgn
+        if node.children[0] == :default
+          put 'default '
+          args[0] = node.children[1]
+        else
+          put 'const '
+        end
+      elsif node.respond_to?(:type) &&
+        node.type == :array &&
+        node.children[0].respond_to?(:type) &&
+        (
+          node.children[0].type == :const ||
+          node.children[0].type == :send ||
+          (node.children[0].type == :hash && node.children[0].children[0].children[0].children[0] == :default )
+        )
+        final_export = true
+        put '{ '
+        node.children.each_with_index do |arg, index|
+          put ', ' unless index == 0
+          if arg.type == :hash && arg.children[0].children[0].children[0] == :default
+            put arg.children[0].children[1].children[1]
+            put ' as default'
+          else
+            parse arg
+          end
+        end
+        put ' }'
       end
 
-      args.each_with_index do |arg, index|
-        put ', ' unless index == 0
-        parse arg
+      unless final_export
+        args.each_with_index do |arg, index|
+          put ', ' unless index == 0
+          parse arg
+        end
       end
     end
   end