ruby2js 3.3.5 → 3.5.2

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,10 +97,12 @@ 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|
                     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

@@ -6,15 +6,64 @@ module Ruby2JS
     # NOTE: import is a synthetic 
 
     handle :import do |path, *args|
+      if module_type == :cjs
+        # only the subset of import syntaxes generated by filters are handled here
+        if Parser::AST::Node === args.first and args.first.type == :attr
+          return parse s(:casgn, *args.first.children, 
+            s(:send, nil, :require, s(:str, Array(path).first))), :statement
+        elsif Array === args.first and args.first.length == 1
+          target = args.first.first
+          if Parser::AST::Node === target and target.type == :attr and target.children.first == nil
+            return parse s(:casgn, *target.children, 
+              s(:attr, s(:send, nil, :require, s(:str, Array(path).first)), target.children.last)),
+              :statement
+          end
+        end
+      end
+
       put 'import '
 
-      args.each_with_index do |arg, index|
-        put ', ' unless index == 0
-        parse arg
-      end
+      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)
+
+        # 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]}"
 
-      put ' from '
-      put path.inspect
+          # advance to the next kwarg, aka from
+          from_kwarg_position = 1
+        end
+
+        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 +73,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

data/lib/ruby2js/converter/ivar.rb

@@ -6,18 +6,26 @@ module Ruby2JS
     handle :ivar do |var|
       if self.ivars and self.ivars.include? var
         parse s(:hostvalue, self.ivars[var])
-      elsif es2020
-        parse s(:attr, s(:self), var.to_s.sub('@', '#'))
-      else
+      elsif underscored_private
         parse s(:attr, s(:self), var.to_s.sub('@', '_'))
+      else
+        parse s(:attr, s(:self), var.to_s.sub('@', '#'))
       end
     end
 
     handle :hostvalue do |value|
       case value
       when Hash
-        parse s(:hash, *value.map {|key, hvalue| s(:pair, s(:hostvalue, key), 
-          s(:hostvalue, hvalue))})
+        parse s(:hash, *value.map {|key, hvalue| 
+          case key
+          when String
+            s(:pair, s(:str, key), s(:hostvalue, hvalue))
+          when Symbol
+            s(:pair, s(:sym, key), s(:hostvalue, hvalue))
+          else
+            s(:pair, s(:hostvalue, key), s(:hostvalue, hvalue))
+          end
+        })
       when Array
         parse s(:array, *value.map {|hvalue| s(:hostvalue, hvalue)})
       when String

data/lib/ruby2js/converter/ivasgn.rb

@@ -7,7 +7,7 @@ module Ruby2JS
     handle :ivasgn do |var, expression=nil|
       multi_assign_declarations if @state == :statement
 
-      put "#{ var.to_s.sub('@', 'this.' + (es2020 ? '#' : '_')) }"
+      put "#{ var.to_s.sub('@', 'this.' + (underscored_private ? '_' : '#')) }"
       if expression
         put " = "; parse expression
       end

data/lib/ruby2js/converter/logical.rb

@@ -89,7 +89,7 @@ module Ruby2JS
     def conditionally_equals(left, right)
       if left == right
         true
-      elsif !left or !right or left.type != :csend or right.type != :send
+      elsif !left.respond_to?(:type) or !left or !right or left.type != :csend or right.type != :send
         false
       else
         conditionally_equals(left.children.first, right.children.first) &&

data/lib/ruby2js/converter/return.rb

@@ -14,7 +14,7 @@ module Ruby2JS
 
     EXPRESSIONS = [ :array, :float, :hash, :int, :lvar, :nil, :send, :attr,
       :str, :sym, :dstr, :dsym, :cvar, :ivar, :zsuper, :super, :or, :and,
-      :block, :const, :true, :false, :xnode ]
+      :block, :const, :true, :false, :xnode, :taglit, :self ]
 
     handle :autoreturn do |*statements|
       return if statements == [nil]
@@ -55,6 +55,8 @@ module Ruby2JS
         node = block.pop
         children = node.children.dup
         (1...children.length).each do |i|
+          next if children[i].nil? # case statements without else clause end with nil
+
           if children[i].type == :when
             gchildren = children[i].children.dup
             if !gchildren.empty? and EXPRESSIONS.include? gchildren.last.type

data/lib/ruby2js/converter/taglit.rb

@@ -0,0 +1,13 @@
+module Ruby2JS
+  class Converter
+
+   # (taglit
+   #   (arg :tag)
+   #   (dstr)
+
+    handle :taglit do |tag, *children|
+      put tag.children.first
+      parse_all(*children, join: '')
+    end
+  end
+end

data/lib/ruby2js/converter/yield.rb

@@ -0,0 +1,12 @@
+module Ruby2JS
+  class Converter
+
+    # (yield
+    #   (arg 'a'))
+
+    handle :yield do |*args|
+      put '_implicitBlockYield'
+      put "("; parse_all(*args, join: ', '); put ')'
+    end
+  end
+end

data/lib/ruby2js/filter/camelCase.rb

@@ -1,5 +1,9 @@
 require 'ruby2js'
 
+# Note care is taken to run all the filters first before camelCasing.
+# This ensures that Ruby methods like each_pair can be mapped to
+# JavaScript before camelcasing.
+
 module Ruby2JS
   module Filter
     module CamelCase
@@ -9,75 +13,114 @@ module Ruby2JS
         attr_accessor
       }
 
+      CAPS_EXCEPTIONS = {
+        "innerHtml" => "innerHTML",
+        "innerHtml=" => "innerHTML=",
+        "outerHtml" => "outerHTML",
+        "outerHtml=" => "outerHTML=",
+        "encodeUri" => "encodeURI",
+        "encodeUriComponent" => "encodeURIComponent",
+        "decodeUri" => "decodeURI",
+        "decodeUriComponent" => "decodeURIComponent"
+      }
+
       def camelCase(symbol)
-        symbol.to_s.gsub(/_[a-z]/) {|match| match[1].upcase}
+        should_symbolize = symbol.is_a?(Symbol)
+        symbol = symbol
+                  .to_s
+                  .gsub(/(?!^)_[a-z0-9]/) {|match| match[1].upcase}
+                  .gsub(/^(.*)$/) {|match| CAPS_EXCEPTIONS[match] || match }
+        should_symbolize ? symbol.to_sym : symbol
       end
 
       def on_send(node)
+        node = super
+        return node unless [:send, :csend, :attr].include? node.type
+
         if node.children[0] == nil and WHITELIST.include? node.children[1].to_s
-          super
-        elsif node.children[1] =~ /_.*\w$/
-          super S(:send , node.children[0],
+          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])),
+            camelCase(node.children[1]), *node.children[2..-1])
+        elsif node.children[1] =~ /_.*\w[=!?]?$/
+          S(node.type, node.children[0],
             camelCase(node.children[1]), *node.children[2..-1])
         else
-          super
+          node
         end
       end
+      
+      def on_csend(node)
+        on_send(node)
+      end
+
+      def on_attr(node)
+        on_send(node)
+      end
+
+      def handle_generic_node(node, node_type)
+        return node if node.type != node_type
 
-      def on_def(node)
         if node.children[0] =~ /_.*\w$/
-          super S(:def , camelCase(node.children[0]), *node.children[1..-1])
+          S(node_type , camelCase(node.children[0]), *node.children[1..-1])
         else
-          super
+          node
         end
       end
 
+      def on_def(node)
+        handle_generic_node(super, :def)
+      end
+
       def on_optarg(node)
-        if node.children[0] =~ /_.*\w$/
-          super S(:optarg , camelCase(node.children[0]), *node.children[1..-1])
-        else
-          super
-        end
+        handle_generic_node(super, :optarg)
+      end
+
+      def on_kwoptarg(node)
+        handle_generic_node(super, :kwoptarg)
       end
 
       def on_lvar(node)
-        if node.children[0] =~ /_.*\w$/
-          super S(:lvar , camelCase(node.children[0]), *node.children[1..-1])
-        else
-          super
-        end
+        handle_generic_node(super, :lvar)
+      end
+
+      def on_ivar(node)
+        handle_generic_node(super, :ivar)
+      end
+
+      def on_cvar(node)
+        handle_generic_node(super, :cvar)
       end
 
       def on_arg(node)
-        if node.children[0] =~ /_.*\w$/
-          super S(:arg , camelCase(node.children[0]), *node.children[1..-1])
-        else
-          super
-        end
+        handle_generic_node(super, :arg)
       end
 
       def on_lvasgn(node)
-        if node.children[0] =~ /_.*\w$/
-          super S(:lvasgn , camelCase(node.children[0]), *node.children[1..-1])
-        else
-          super
-        end
+        handle_generic_node(super, :lvasgn)
+      end
+
+      def on_ivasgn(node)
+        handle_generic_node(super, :ivasgn)
+      end
+
+      def on_cvasgn(node)
+        handle_generic_node(super, :cvasgn)
       end
 
       def on_sym(node)
-        if node.children[0] =~ /_.*\w$/
-          super S(:sym , camelCase(node.children[0]), *node.children[1..-1])
-        else
-          super
-        end
+        handle_generic_node(super, :sym)
       end
 
       def on_defs(node)
+        node = super
+        return node if node.type != :defs
+
         if node.children[1] =~ /_.*\w$/
-          super S(:defs , node.children[0],
+          S(:defs , node.children[0],
             camelCase(node.children[1]), *node.children[2..-1])
         else
-          super
+          node
         end
       end
     end

data/lib/ruby2js/filter/esm.rb

@@ -1,69 +1,98 @@
 require 'ruby2js'
 
+Ruby2JS.module_default = :esm
+
 module Ruby2JS
   module Filter
     module ESM
       include SEXP
 
       def initialize(*args)
-        @esm_include = nil
         super
+        @esm = true # signal for other filters
+        @esm_imports = nil
+      end
+
+      def options=(options)
+        super
+        @esm_autoimports = options[:autoimports]
+        return unless @esm_autoimports
       end
 
       def process(node)
-        return super if @esm_include
-        @esm_include = Set.new
-        @esm_exclude = Set.new
-        @esm_export = nil
+        return super if @esm_imports or not @esm_autoimports
+        @esm_imports = Set.new
         result = super
 
-        esm_walk(result)
-
-        inventory = (@esm_include - @esm_exclude).to_a.sort
-
-        if inventory.empty? and not @esm_export
+        if @esm_imports.empty?
           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
+          s(:begin, *@esm_imports.to_a.map {|token|
+            s(:import, @esm_autoimports[token], s(:const, nil, token))
+          }, result)
+        end
+      end
 
-          list.push result
+      def on_send(node)
+        target, method, *args = node.children
+        return super unless target.nil?
 
-          if @esm_export
-            list.push s(:export, :default, s(:const, nil, @esm_export))
+        if method == :import
+          # don't do the conversion if the word import is followed by a paren
+          if node.loc.respond_to? :selector
+            selector = node.loc.selector
+            if selector and selector.source_buffer
+              return super if selector.source_buffer.source[selector.end_pos] == '('
+            end
           end
 
-          s(:begin, *list.compact)
-        end
-      end
+          if args[0].type == :str
+            # import "file.css"
+            #   => import "file.css"
+            s(:import, args[0].children[0])
+          elsif args.length == 1 and \
+             args[0].type == :send and \
+            args[0].children[0].nil? and \
+            args[0].children[2].type == :send and \
+            args[0].children[2].children[0].nil? and \
+            args[0].children[2].children[1] == :from and \
+            args[0].children[2].children[2].type == :str
+            # import name from "file.js"
+            #  => import name from "file.js"
+            s(:import,
+              [args[0].children[2].children[2].children[0]],
+              process(s(:attr, nil, args[0].children[1])))
 
-      # 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
+          else
+            # import Stuff, "file.js"
+            #   => import Stuff from "file.js"
+            # import Stuff, from: "file.js"
+            #   => import Stuff from "file.js"
+            # import Stuff, as: "*", from: "file.js"
+            #   => 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]) : 
+              process_all(args[0].children)
+            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)
+          super
+        else
+          super
         end
+      end
 
-        # recurse
-        node.children.each do |child|
-          esm_walk(child) if Parser::AST::Node === child
+      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)
         end
+        super
       end
     end