ruby2js 2.1.24 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf2d8e7dd8a01998e41d419eca3fdf1c37f596ed
-  data.tar.gz: '018be6424d191987b685162c9c8a9328d6375650'
+  metadata.gz: 0b1bcb8158bb81cdfafcf70eb22f84ad5dc195b1
+  data.tar.gz: '08d8a3e28b785aa35c52317b86f5749cebce31de'
 SHA512:
-  metadata.gz: 7da7b8a123718cb0609a34076fa02865561f7b56a4f394c1f8919125c8d6a79ebccc65af70c4429db55783a000494f6ff6b5fbd24ffb1dd1cc2981aaaae87bda
-  data.tar.gz: 0acc39d55555d57484e8c73ec824d40ed8b17ef5881f5a78511228bcdd74b07e4e9522bf1a6d05b52adb8fb21d06f8d7f21435d2c875e81c9343d92010a220f6
+  metadata.gz: 3c4946688aa439dd57d84de8115f1fbee1155a7d42227acf6ab2633ce6e6eb8c6e7f0fc7c7e322badd831642e856cc1991439c97beda892cd212f99e3cc8aa51
+  data.tar.gz: d8e945b65e77e4aacd05e36864f505c7cd454f8b00f788d37e7254f642df860cde0c9a6ebee44d854ba6c706a1c768d3c4dbe5c3e65ec86df660648b5ccf5ccd

data/README.md

@@ -9,12 +9,35 @@ Minimal yet extensible Ruby to JavaScript conversion.
 Description
 ---
 
-The base package maps Ruby syntax to JavaScript semantics.  For example,
-a Ruby Hash literal becomes a JavaScript Object literal.  Ruby symbols
-become JavaScript strings.  Ruby method calls become JavaScript function
-calls IF there are either one or more arguments passed OR parenthesis are
-used, otherwise Ruby method calls become JavaScript property accesses.
-By default, methods and procs return `undefined`.
+The base package maps Ruby syntax to JavaScript semantics.
+For example:
+
+  * a Ruby Hash literal becomes a JavaScript Object literal
+  * Ruby symbols become JavaScript strings.
+  * Ruby method calls become JavaScript function calls IF
+    there are either one or more arguments passed OR
+    parenthesis are used
+  * otherwise Ruby method calls become JavaScript property accesses.
+  * by default, methods and procs return `undefined`
+  * splats are handled (may need to try around or read transliteration_spec)
+  * ruby string interpolation is expanded into string + operations
+  * `and` and `or` become `&&` and `||`
+  * `a ** b` becomes `Math.pow(a,b)`
+  * `<< a` becomes `.push(a)`
+  * `unless` becomes `if !`
+  * `until` becomes `while !`
+  * `case` and `when` becomes `switch` and `case`
+  * ruby for loops become js for loops
+  * `(1...4).step(2){` becomes `for (var i = 1; i < 4; i += 2) {`
+  * `x.forEach { next }` becomes `x.forEach(function() {return})`
+  * `lambda {}` and `proc {}` becomes `function() {}`
+  * `class Person; end` becomes `function Person() {}`
+  * instance methods become prototype methods
+  * instance variables become underscored, `@name` becomes `this._name`
+  * self is assigned to this is if used
+  * 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`
 
 Ruby attribute accessors, methods defined with no parameters and no
 parenthesis, as well as setter method definitions, are
@@ -47,6 +70,18 @@ require 'ruby2js/filter/functions'
 puts Ruby2JS.convert('"2A".to_i(16)')
 ```
 
+Enable ES2015 support:
+
+```ruby
+puts Ruby2JS.convert('"#{a}"', eslevel: 2015)
+```
+
+Enable strict support:
+
+```ruby
+puts Ruby2JS.convert('a=1', strict: true)
+```
+
 With [ExecJS](https://github.com/sstephenson/execjs):
 ```ruby
 require 'ruby2js/execjs'
@@ -140,9 +175,6 @@ In general, making use of a filter is as simple as requiring it.  If multiple
 filters are selected, they will all be applied in parallel in one pass through
 the script.
 
-* <a id="strict" href="https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/filter/strict.rb">strict</a>
-  adds `'use strict';` to the output.
-
 * <a id="return" href="https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/filter/return.rb">return</a>
   adds `return` to the last expression in functions.
 
@@ -164,7 +196,9 @@ the script.
     * `.clear` becomes `.length = 0`
     * `.delete` becomes `delete target[arg]`
     * `.downcase` becomes `.toLowerCase`
-    * `.each` becomes `forEach`
+    * `.each` becomes `for (i in ...) {}`
+    * `.each_key` becomes `Object.keys().forEach`
+    * `.each_value` becomes `for (i in ...) {}`
     * `.each_with_index` becomes `.forEach`
     * `.end_with?` becomes `.slice(-arg.length) == arg`
     * `.empty?` becomes `.length == 0`
@@ -200,6 +234,7 @@ the script.
     * `[n...m]` becomes `.slice(n,m)`
     * `[n..m]` becomes `.slice(n,m+1)`
     * `[/r/, n]` becomes `.match(/r/)[n]`
+    * `(1..2).each {|i| ...}` becomes `for (var i=1 i<=2; i+=1)`
     * `"string" * length` becomes `new Array(length + 1).join("string")`
     * `.sub!` and `.gsub!` become equivalent `x = x.replace` statements
     * `.map!`, `.reverse!`, and `.select` become equivalent
@@ -332,39 +367,6 @@ the script.
     * defaults the fourth parameter of $$.post to `"json"`, allowing Ruby block
       syntax to be used for the success function.
 
-* <a id="angularrb" href="https://github.com/rubys/ruby2js/blob/master/spec/angularrb.rb">angularrb</a>
-
-    * maps Ruby `module` to `angular.module`
-    * maps `filter`, `controller`, `factory`, and `directive` to calls to
-      angular module functions.
-    * maps `use` statements to formal arguments or array values (as
-      appropriate) depending on the module function.
-    * maps `watch` statements to calls to `$scope.$watch`.
-    * tracks globals variable and constant references and adds additional
-      implicit `use` statements
-    * maps constant assignments in an angular module to a filter
-    * maps class definitions in an angular module to a filter
-    * within a controller or within a `link` method in a directive:
-        * maps `apply`, `broadcast`, `digest`, `emit`, `eval`, `evalAsync`, and
-          `parent` calls to `$scope` functions.
-        * maps `apply!`, `broadcast!`, `digest!`, `eval!`, and `evalAsync!`
-          calls to `$rootScope` functions.
-        * maps `filter` calls to '$filter` calls.
-        * maps `timeout` and `interval` calls with a block to `$timeout` and
-          `$interval` calls where the block is passed as the first parameter.
-
-* <a id="angular-route" href="https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/filter/angular-routerb.rb">angular-route</a>
-
-    * maps `case` statements on `$routeProvider` to angular.js module
-      configuration.
-    * adds implicit module `use` of `ngRoute` when such a `case` statement
-      is encountered
-
-* <a id="angular-resource" href="https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/filter/angular-resource.rb">angular-resource</a>
-    * maps `$resource.new` statements on `$resource` function calls.
-    * adds implicit module `use` of `ngResource` when `$resource.new` calls
-      are encountered
-
 * <a id="minitest-jasmine" href="https://github.com/rubys/ruby2js/blob/master/spec/minitest-jasmine.rb">minitest-jasmine</a>
     * maps subclasses of `Minitest::Test` to `describe` calls
     * maps `test_` methods inside subclasses of `Minitest::Test` to `it` calls
@@ -393,13 +395,52 @@ the script.
   and [wiki](https://github.com/rubys/wunderbar/blob/master/demo/wiki.rb) make
   use of the jquery filter.
 
-* [angularjs](https://github.com/rubys/wunderbar/blob/master/demo/angularjs.rb)
-  makes use of the angular filters to implement the
-  [angular.js tutorial](http://docs.angularjs.org/tutorial).  This demo
-  includes:
-    * [view](https://github.com/rubys/wunderbar/blob/master/demo/views/index._html)
-    * [partials](https://github.com/rubys/wunderbar/tree/master/demo/partials)
-    * [js](https://github.com/rubys/wunderbar/tree/master/demo/js)
+ES2015 support
+---
+
+When option `eslevel: 2015` is provided, the following additional
+conversions are made:
+
+* `"#{a}"` becomes <code>\`${a}\`</code>
+* `a = 1` becomes `let a = 1`
+* `A = 1` becomes `const A = 1`
+* `a, b = b, a` becomes `[a, b] = [b, a]`
+* `a, (foo, *bar) = x` becomes `let [a, [foo, ...bar]] = x`
+* `def f(a, (foo, *bar))` becomes `function f(a, [foo, ...bar])`
+* `def a(b=1)` becomes `function a(b=1)`
+* `def a(*b)` becomes `function a(...b)`
+* `.each_key` becomes `for (i of ...) {}`
+* `a(*b)` becomes `a(...b)`
+* `"#{a}"` becomes <code>\`${a}\`</code>
+* `lambda {|x| x}` becomes `(x) => {return x}`
+* `proc {|x| x}` becomes `(x) => {x}`
+* `a {|x|}` becomes `a((x) => {})`
+* `class Person; end` becomes `class Person {}`
+
+ES2015 class support includes constructors, super, methods, class methods,
+instance methods, instance variables, class variables, getters, setters,
+attr_accessor, attr_reader, attr_writer, etc.
+
+Additionally, the `functions` filter will provide the following conversion:
+
+* `Array(x)` becomes `Array.from(x)`
+* `.inject(n) {}` becomes `.reduce(() => {}, n)`
+
+ES2016 support
+---
+
+When option `eslevel: 2016` is provided, the following additional
+conversion is made:
+
+* `a ** b` becomes `a ** b`
+
+ES2017 support
+---
+
+When option `eslevel: 2017` is provided, the following additional
+conversion is made by the `functions` filter:
+
+* `.each_entry` becomes `Object.entries().forEach`
 
 Picking a Ruby to JS mapping tool
 ---

data/lib/ruby2js/converter/args.rb

@@ -9,5 +9,15 @@ module Ruby2JS
     handle :args do |*args|
       parse_all(*args, join: ', ')
     end
+
+    handle :mlhs do |*args|
+      if es2015
+        put '['
+        parse_all(*args, join: ', ')
+        put ']'
+      else
+        raise NotImplementedError, "destructuring requires ES2015"
+      end
+    end
   end
 end

data/lib/ruby2js/converter/block.rb

@@ -58,7 +58,7 @@ module Ruby2JS
         # consisting of an anonymous function
         block ||= s(:begin)
         function = @ast.updated(:def, [nil, args, block])
-        parse s(:send, *call.children, function)
+        parse s(@ast.children[0].type, *call.children, function), @state
       end
     end
   end

data/lib/ruby2js/converter/case.rb

@@ -31,7 +31,7 @@ module Ruby2JS
         if scope
           vars = @vars.select {|key, value| value == :pending}.keys
           unless vars.empty?
-            insert mark, "var #{vars.join(', ')}#{@sep}"
+            insert mark, "#{es2015 ? 'let' : 'var'} #{vars.join(', ')}#{@sep}"
             vars.each {|var| @vars[var] = true}
           end
         end

data/lib/ruby2js/converter/casgn.rb

@@ -6,8 +6,13 @@ module Ruby2JS
 
     handle :casgn do |cbase, var, value|
       begin
-        put "var "
+        if es2015
+          put "const "
+        else
+          put "var "
+        end
 
+        cbase ||= @rbstack.map {|rb| rb[var]}.compact.last
         (parse cbase; put '.') if cbase
 
         put "#{ var } = "; parse value

data/lib/ruby2js/converter/class.rb

@@ -9,6 +9,11 @@ module Ruby2JS
     # NOTE: :prop and :method macros are defined at the bottom of this file
 
     handle :class do |name, inheritance, *body|
+      if es2015
+        parse @ast.updated(:class2)
+        return
+      end
+
       if inheritance
         init = s(:def, :initialize, s(:args), s(:super))
       else
@@ -48,7 +53,7 @@ module Ruby2JS
               # method: add to prototype
               s(:method, s(:attr, name, :prototype),
                 :"#{m.children[0].to_s.chomp('!')}=",
-                s(:block, s(:send, nil, :proc), *m.children[1..-1]))
+                s(:def, nil, *m.children[1..-1]))
             end
           end
 
@@ -57,7 +62,7 @@ module Ruby2JS
             # class property setter
             s(:prop, name, m.children[1].to_s[0..-2] =>
                 {enumerable: s(:true), configurable: s(:true),
-                set: s(:block, s(:send, nil, :proc), *m.children[2..-1])})
+                set: s(:def, nil, *m.children[2..-1])})
           elsif m.children[2].children.length == 0 and
             m.children[1] !~ /!/ and m.loc and m.loc.name and
             m.loc.name.source_buffer.source[m.loc.name.end_pos] != '('

data/lib/ruby2js/converter/class2.rb

@@ -0,0 +1,167 @@
+module Ruby2JS
+  class Converter
+
+    # (class2
+    #   (const nil :A)
+    #   (const nil :B)
+    #   (...)
+
+    # NOTE: this is the es2015 version of class
+
+    handle :class2 do |name, inheritance, *body|
+      if name.type == :const and name.children.first == nil
+        put 'class '
+        parse name
+      else
+        parse name
+        put ' = class'
+      end
+
+      if inheritance
+        put ' extends '
+        parse inheritance
+      end
+
+      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
+        @rbstack.push({})
+
+        post = []
+        skipped = false
+        body.each_with_index do |m, index|
+          put(index == 0 ? @nl : @sep) unless skipped
+          skipped = false
+
+          # intercept async definitions
+          if es2017 and m.type == :send and m.children[0..1] == [nil, :async]
+            child = m.children[2]
+            if child.type == :def
+              m = child.updated(:async)
+            elsif child.type == :defs and child.children[0].type == :self
+              m = child.updated(:asyncs)
+            end
+          end
+
+          if m.type == :def || m.type == :async
+            @prop = m.children.first
+
+            if @prop == :initialize
+              @prop = :constructor 
+              m = m.updated(m.type, [@prop, *m.children[1..2]])
+            elsif not m.is_method?
+              @rbstack.last[@prop] = s(:self)
+              @prop = "get #{@prop}"
+              m = m.updated(m.type, [*m.children[0..1], 
+                s(:autoreturn, m.children[2])])
+            elsif @prop.to_s.end_with? '='
+              @prop = @prop.to_s.sub('=', '').to_sym
+              @rbstack.last[@prop] = s(:self)
+              m = m.updated(m.type, [@prop, *m.children[1..2]])
+              @prop = "set #{@prop}"
+            elsif @prop.to_s.end_with? '!'
+              @prop = @prop.to_s.sub('!', '')
+              m = m.updated(m.type, [@prop, *m.children[1..2]])
+            else
+              @rbstack.last[@prop] = s(:self)
+            end
+
+            begin
+              @instance_method = m
+              parse m
+            ensure
+              @instance_method = nil
+            end
+
+          elsif 
+            [:defs, :asyncs].include? m.type and m.children.first.type == :self
+          then
+
+            @prop = "static #{m.children[1]}"
+            if not m.is_method?
+              @prop = "static get #{m.children[1]}"
+              m = m.updated(m.type, [*m.children[0..2], 
+                s(:autoreturn, m.children[3])])
+            elsif @prop.to_s.end_with? '='
+              @prop = "static set #{m.children[1].to_s.sub('=', '')}"
+            elsif @prop.to_s.end_with? '!'
+              m = m.updated(m.type, [m.children[0],
+                m.children[1].to_s.sub('!', ''), *m.children[2..3]])
+              @prop = "static #{m.children[1]}"
+            end
+
+            @prop.sub! 'static', 'static async' if m.type == :asyncs
+
+            m = m.updated(:def, m.children[1..3])
+            parse m
+
+          elsif m.type == :send and m.children.first == nil
+            if m.children[1] == :attr_accessor
+              m.children[2..-1].each_with_index do |child_sym, index2|
+                put @sep unless index2 == 0
+                var = child_sym.children.first
+                put "get #{var}() {#{@nl}return this._#{var}#@nl}#@sep"
+                put "set #{var}(#{var}) {#{@nl}this._#{var} = #{var}#@nl}"
+              end
+            elsif m.children[1] == :attr_reader
+              m.children[2..-1].each_with_index do |child_sym, index2|
+                put @sep unless index2 == 0
+                var = child_sym.children.first
+                put "get #{var}() {#{@nl}return this._#{var}#@nl}"
+              end
+            elsif m.children[1] == :attr_writer
+              m.children[2..-1].each_with_index do |child_sym, index2|
+                put @sep unless index2 == 0
+                var = child_sym.children.first
+                put "set #{var}(#{var}) {#{@nl}this._#{var} = #{var}#@nl}"
+              end
+            else
+              skipped = true
+            end
+
+          else
+            skipped = true
+
+            if m.type == :casgn and m.children[0] == nil
+              @rbstack.last[m.children[1]] = name
+            elsif m.type == :alias
+              @rbstack.last[m.children[0]] = name
+            end
+          end
+
+          post << m if skipped
+        end
+
+        put @nl unless skipped
+        put '}'
+
+        post.each do |m|
+          put @sep
+          if m.type == :alias
+            parse name
+            put '.prototype.'
+            put m.children[0].children[0]
+            put ' = '
+            parse name
+            put '.prototype.'
+            put m.children[1].children[0]
+          else
+            parse m, :statement
+          end
+        end
+
+      ensure
+        @class_name = class_name
+        @class_parent = class_parent
+        @rbstack.pop
+      end
+    end
+  end
+end

data/lib/ruby2js/converter/def.rb

@@ -6,7 +6,7 @@ module Ruby2JS
     #     (arg :x)
     #   (...)
 
-    handle :def do |name, args, body=nil|
+    handle :def, :async do |name, args, body=nil|
       body ||= s(:begin)
       if name =~ /[!?]$/
         raise NotImplementedError, "invalid method name #{ name }"
@@ -16,7 +16,7 @@ module Ruby2JS
       vars.merge! @vars unless name
       if args and !args.children.empty?
         # splats
-        if args.children.last.type == :restarg
+        if args.children.last.type == :restarg and not es2015
           if args.children[-1].children.first
             body = s(:begin, body) unless body.type == :begin
             assign = s(:lvasgn, args.children[-1].children.first,
@@ -68,7 +68,7 @@ module Ruby2JS
 
         # optional arguments
         args.children.each_with_index do |arg, i|
-          if arg.type == :optarg
+          if arg.type == :optarg and not es2015
             body = s(:begin, body) unless body.type == :begin
             argname, value = arg.children
             children = args.children.dup
@@ -88,13 +88,50 @@ module Ruby2JS
         end
       end
 
+      put 'async ' if @ast.type == :async
+
+      # es2015 fat arrow support
+      if not name and es2015 and @state != :method
+        put '('; parse args; put ') => '
+
+        expr = body
+        expr = expr.children.first if expr.type == :autoreturn
+        while expr.type == :begin and expr.children.length == 1
+          expr = expr.children.first
+        end
+
+        if EXPRESSIONS.include? expr.type
+          if expr.type == :send and expr.children[0..1] == [nil, :raise]
+            style = :statement
+          else
+            style = :expression
+          end
+        elsif 
+          expr.type == :if and expr.children[1] and expr.children[2] and
+          EXPRESSIONS.include? expr.children[1].type and
+          EXPRESSIONS.include? expr.children[2].type
+        then
+          style = :expression
+        else
+          style = :statement
+        end
+
+        if style == :expression
+          expr.type == :hash ? group(expr) : parse(expr)
+        else
+          put "{#{@nl}"; scope body, vars; put "#{@nl}}"
+        end
+
+        return
+      end
+
       nl = @nl unless body == s(:begin)
       begin
-        if name
-          put "function #{name}"
-        elsif @prop
+        if @prop
           put @prop
           @prop = nil
+        elsif name
+          put "function #{name}"
         else
           put 'function'
         end
@@ -116,5 +153,16 @@ module Ruby2JS
         @block_depth -= 1 if @block_depth
       end
     end
+
+    handle :optarg do |name, value|
+      put name
+      put '='
+      parse value 
+    end
+
+    handle :restarg do |name|
+      put '...'
+      put name
+    end
   end
 end

data/lib/ruby2js/converter/defs.rb

@@ -5,10 +5,17 @@ module Ruby2JS
     #   (args)
     #   (...)
 
-    # NOTE: defp is only produced by filters
+    # NOTE: defp and asyncs are only produced by filters
 
-    handle :defs, :defp do |target, method, args, body|
-      parse transform_defs(target, method, args, body)
+    handle :defs, :defp, :asyncs do |target, method, args, body|
+      node = transform_defs(target, method, args, body)
+
+      if node.type == :send and @ast.type == :asyncs
+        node = node.updated(nil, [*node.children[0..1],
+          node.children[2].updated(:async)])
+      end
+
+      parse node, :method
     end
 
     def transform_defs(target, method, args, body)
@@ -23,8 +30,7 @@ module Ruby2JS
           set: s(:block, s(:send, nil, :proc), args,
           body)})
       else
-        node = s(:send, target, "#{method}=",
-          s(:block, s(:send, nil, :proc), args, body))
+        node = s(:send, target, "#{method}=", s(:def, nil, args, body))
       end
 
       @comments[node] = @comments[@ast] if @comments[@ast]

data/lib/ruby2js/converter/dstr.rb

@@ -10,6 +10,32 @@ module Ruby2JS
     #   (...))
 
     handle :dstr, :dsym do |*children|
+      if es2015
+	put '`'
+
+        # gather length of string parts; if long enough, newlines will
+        # not be escaped
+	length = children.select {|child| child.type==:str}.
+	  map {|child| child.children.last.length}.inject(:+)
+
+	children.each do |child|
+	  if child.type == :str
+	    str = child.children.first.inspect[1..-2].gsub('${', '$\{')
+	    if length > 40
+	      put str.gsub("\\n", "\n")
+	    else
+	      put str
+	    end
+	  else
+	    put '${'
+	    parse child
+	    put '}'
+	  end
+	end
+	put '`'
+	return
+      end
+
       children.each_with_index do |child, index|
         put ' + ' unless index == 0
 

data/lib/ruby2js/converter/for.rb

@@ -9,16 +9,16 @@ module Ruby2JS
     #     (int 1))
     #   (...)
 
-    handle :for do |var, expression, block|
+    handle :for, :for_of do |var, expression, block|
       begin
         next_token, @next_token = @next_token, :continue
-        put "for (var "; parse var
+        put "for (#{es2015 ? 'let' : 'var'} "; parse var
         if [:irange, :erange].include? expression.type
           put ' = '; parse expression.children.first; put '; '; parse var
           (expression.type == :erange ? put(' < ') : put(' <= '))
           parse expression.children.last; put '; '; parse var; put '++'
         else
-          put ' in '; parse expression; 
+          put (@ast.type==:for_of ? ' of ' : ' in '); parse expression; 
         end
         puts ') {'; scope block; sput '}'
       ensure