ruby2js 3.3.6 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 888fb767c9a587a64db5b2739009627f3db16f1a5f9d9d032cd98d3d9fdc2167
-  data.tar.gz: e32434b17986c142d784156bc6fbf4e7429bd9a0c333bd3bc8aa86036cc57276
+  metadata.gz: df66ef5836777a349c4f702cb4482631c3260f95f82d2f292ae914dfc9de5d86
+  data.tar.gz: 6d4d513cdc4130c3e2a1af390441fd8e0642dd74b331498e4ab60799965c072b
 SHA512:
-  metadata.gz: 9229d6f6b976c755fb82af395ff5ea4f111703256408876efc035047ab29c60737c36438d354d137d1877c536bb20bc01f6ac72ea95f5128b41bfa5309894595
-  data.tar.gz: f465097e3b8352bb3e4d74c4b18d2f60ed934956f8384c05866dcc120ca039deb8f09ad61275f98cfa3ba21c92fd05ef821b52282cfb75e027dedd0b461d1b30
+  metadata.gz: b6b1f96c9e312700bd774f1d6344c21f67c48da1a9fea50f927ade02910541c56aa31fab988bd9a9e16a136e7112cbc830bfdda80bfa6486f5015e9a2edcf360
+  data.tar.gz: 4b151db4cfe119e206ef46ac89b870754a531e67cf6b6026aec4d1639563220079db3d37d3b95e2070bb8d0c4f8bfdeead16bcb76f10d2a593d6fa4b7de224b3

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()`
@@ -677,7 +694,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/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

@@ -101,6 +101,8 @@ module Ruby2JS
                   walk = proc do |ast|
                     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

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