ruby2js 3.5.3 → 4.0.2

data/lib/ruby2js.rb

@@ -10,9 +10,15 @@ end
 
 require 'ruby2js/converter'
 require 'ruby2js/filter'
+require 'ruby2js/namespace'
 
 module Ruby2JS
   class SyntaxError < RuntimeError
+    attr_reader :diagnostic
+    def initialize(message, diagnostic=nil)
+      super(message)
+      @diagnostic = diagnostic
+    end
   end
 
   @@eslevel_default = 2009 # ecmascript 5
@@ -61,26 +67,42 @@ module Ruby2JS
       include Ruby2JS::Filter
       BINARY_OPERATORS = Converter::OPERATORS[2..-1].flatten
 
-      attr_accessor :prepend_list
+      attr_accessor :prepend_list, :disable_autoimports, :namespace
 
       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)
         @options = options
 
-        @included = @@included
-        @excluded = @@excluded
+        @included = Filter.included_methods
+        @excluded = Filter.excluded_methods
 
         include_all if options[:include_all]
         include_only(options[:include_only]) if options[:include_only]
         include(options[:include]) if options[:include]
         exclude(options[:exclude]) if options[:exclude]
+
+        filters = options[:filters] || DEFAULTS
+        @modules_enabled =
+          (defined? Ruby2JS::Filter::ESM and
+          filters.include? Ruby2JS::Filter::ESM) or
+          (defined? Ruby2JS::Filter::CJS and
+          filters.include? Ruby2JS::Filter::CJS)
+      end
+
+      def modules_enabled?
+        @modules_enabled
       end
 
       def es2015
@@ -111,6 +133,10 @@ module Ruby2JS
         @options[:eslevel] >= 2021
       end
 
+      def es2022
+        @options[:eslevel] >= 2022
+      end
+
       def process(node)
         ast, @ast = @ast, node
         replacement = super
@@ -125,6 +151,7 @@ module Ruby2JS
       end
 
       # handle all of the 'invented/synthetic' ast types
+      def on_assign(node); end
       def on_async(node); on_def(node); end
       def on_asyncs(node); on_defs(node); end
       def on_attr(node); on_send(node); end
@@ -132,17 +159,23 @@ module Ruby2JS
       def on_await(node); on_send(node); end
       def on_call(node); on_send(node); end
       def on_class_extend(node); on_send(node); end
+      def on_class_hash(node); on_class(node); end
       def on_class_module(node); on_send(node); end
       def on_constructor(node); on_def(node); end
+      def on_deff(node); on_def(node); end
       def on_defm(node); on_defs(node); end
       def on_defp(node); on_defs(node); end
       def on_for_of(node); on_for(node); end
       def on_in?(node); on_send(node); end
       def on_method(node); on_send(node); end
+      def on_module_hash(node); on_module(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_defineProps(node); end
+      def on_hide(node); on_begin(node); end
       def on_nil(node); end
       def on_xnode(node); end
       def on_export(node); end
@@ -160,10 +193,12 @@ module Ruby2JS
             return on_block s(:block, s(:send, *node.children[0..-2]),
               s(:args, s(:arg, :a), s(:arg, :b)), s(:return,
               process(s(:send, s(:lvar, :a), method, s(:lvar, :b)))))
-          else
+          elsif node.children.last.children.first.type == :sym
             return on_block s(:block, s(:send, *node.children[0..-2]),
               s(:args, s(:arg, :item)), s(:return,
               process(s(:attr, s(:lvar, :item), method))))
+          else
+            super
           end
         end
         super
@@ -172,6 +207,7 @@ module Ruby2JS
   end
 
   def self.convert(source, options={})
+    options = options.dup
     options[:eslevel] ||= @@eslevel_default
     options[:strict] = @@strict_default if options[:strict] == nil
     options[:module] ||= @@module_default || :esm
@@ -188,9 +224,11 @@ 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
 
+    namespace = Namespace.new
+
     filters = (options[:filters] || Filter::DEFAULTS)
 
     unless filters.empty?
@@ -205,11 +243,13 @@ module Ruby2JS
       filter = filter.new(comments)
 
       filter.options = options
+      filter.namespace = namespace
       ast = filter.process(ast)
 
-      if filter.prepend_list
+      unless filter.prepend_list.empty?
         prepend = filter.prepend_list.sort_by {|ast| ast.type == :import ? 0 : 1}
-        ast = Parser::AST::Node.new(:begin, [*prepend, ast], location: ast.location)
+        prepend.reject! {|ast| ast.type == :import} if filter.disable_autoimports
+        ast = Parser::AST::Node.new(:begin, [*prepend, ast])
       end
     end
 
@@ -222,7 +262,10 @@ module Ruby2JS
     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]
+    ruby2js.underscored_private = (options[:eslevel] < 2022) || options[:underscored_private]
+
+    ruby2js.namespace = namespace
+
     if ruby2js.binding and not ruby2js.ivars
       ruby2js.ivars = ruby2js.binding.eval \
         'Hash[instance_variables.map {|var| [var, instance_variable_get(var)]}]'
@@ -240,23 +283,25 @@ module Ruby2JS
 
     ruby2js.timestamp options[:file]
 
+    ruby2js.file_name = options[:file] || ast&.loc&.expression&.source_buffer&.name || ''
+
     ruby2js
   end
   
   def self.parse(source, file=nil, line=1)
     buffer = Parser::Source::Buffer.new(file, line)
-    buffer.source = source.encode('utf-8')
+    buffer.source = source.encode('UTF-8')
     parser = Parser::CurrentRuby.new
-    parser.builder.emit_file_line_as_literals=false
-    ast, comments = parser.parse_with_comments(buffer)
-    Parser::CurrentRuby.parse(source.encode('utf-8')) unless ast
-    [ast, comments]
+    parser.diagnostics.all_errors_are_fatal = true
+    parser.diagnostics.consumer = lambda {|diagnostic| nil}
+    parser.builder.emit_file_line_as_literals = false
+    parser.parse_with_comments(buffer)
   rescue Parser::SyntaxError => e
     split = source[0..e.diagnostic.location.begin_pos].split("\n")
     line, col = split.length, split.last.length
     message = "line #{line}, column #{col}: #{e.diagnostic.message}"
     message += "\n in file #{file}" if file
-    raise Ruby2JS::SyntaxError.new(message)
+    raise Ruby2JS::SyntaxError.new(message, e.diagnostic)
   end
 
   def self.find_block(ast, line)

data/lib/ruby2js/converter.rb

@@ -14,7 +14,7 @@ module Ruby2JS
 
   class Converter < Serializer
     attr_accessor :ast
-    
+
     LOGICAL   = :and, :not, :or
     OPERATORS = [:[], :[]=], [:not, :!], [:**], [:*, :/, :%], [:+, :-], 
       [:>>, :<<], [:&], [:^, :|], [:<=, :<, :>, :>=], [:==, :!=, :===, :"!=="],
@@ -34,7 +34,7 @@ module Ruby2JS
 
     VASGN = [:cvasgn, :ivasgn, :gvasgn, :lvasgn]
 
-    attr_accessor :binding, :ivars
+    attr_accessor :binding, :ivars, :namespace
 
     def initialize( ast, comments, vars = {} )
       super()
@@ -66,6 +66,7 @@ module Ruby2JS
       @comparison = :equality
       @or = :logical
       @underscored_private = true
+      @redoable = false
     end
 
     def width=(width)
@@ -160,6 +161,10 @@ module Ruby2JS
       @eslevel >= 2021
     end
 
+    def es2022
+      @eslevel >= 2022
+    end
+
     @@handlers = []
     def self.handle(*types, &block)
       types.each do |type| 
@@ -239,6 +244,34 @@ module Ruby2JS
       end
     end
 
+    def redoable(block)
+      save_redoable = @redoable
+
+      has_redo = proc do |node|
+        node.children.any? do |child|
+          next false unless child.is_a? Parser::AST::Node
+          next true if child.type == :redo
+          next false if %i[for while while_post until until_post].include? child.type
+          has_redo[child]
+        end
+      end
+
+      @redoable = has_redo[@ast]
+
+      if @redoable
+        put es2015 ? 'let ' : 'var '
+        put "redo$#@sep"
+        puts 'do {'
+        put "redo$ = false#@sep"
+        scope block
+        put "#@nl} while(redo$)"
+      else
+        scope block
+      end
+    ensure
+      @redoable = save_redoable
+    end
+
     def timestamp(file)
       super
 
@@ -248,7 +281,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
 
@@ -295,6 +328,7 @@ end
 require 'ruby2js/converter/arg'
 require 'ruby2js/converter/args'
 require 'ruby2js/converter/array'
+require 'ruby2js/converter/assign'
 require 'ruby2js/converter/begin'
 require 'ruby2js/converter/block'
 require 'ruby2js/converter/blockpass'
@@ -314,6 +348,7 @@ require 'ruby2js/converter/dstr'
 require 'ruby2js/converter/fileline'
 require 'ruby2js/converter/for'
 require 'ruby2js/converter/hash'
+require 'ruby2js/converter/hide'
 require 'ruby2js/converter/if'
 require 'ruby2js/converter/in'
 require 'ruby2js/converter/import'
@@ -329,6 +364,7 @@ require 'ruby2js/converter/nil'
 require 'ruby2js/converter/nthref'
 require 'ruby2js/converter/opasgn'
 require 'ruby2js/converter/prototype'
+require 'ruby2js/converter/redo'
 require 'ruby2js/converter/regexp'
 require 'ruby2js/converter/return'
 require 'ruby2js/converter/self'

data/lib/ruby2js/converter/args.rb

@@ -30,13 +30,18 @@ module Ruby2JS
           if kw.type == :kwarg
             put kw.children.first
           elsif kw.type == :kwoptarg
-            put kw.children.first; put ' = '; parse kw.children.last
+            put kw.children.first
+            unless kw.children.last == s(:send, nil, :undefined)
+              put '='; parse kw.children.last
+            end
           elsif kw.type == :kwrestarg
             raise 'Rest arg requires ES2018' unless es2018
             put '...'; put kw.children.first
           end
         end
         put ' }'
+
+        put ' = {}' unless kwargs.any? {|kw| kw.type == :kwarg}
       end
     end
 

data/lib/ruby2js/converter/assign.rb

@@ -0,0 +1,159 @@
+# Kinda like Object.assign, except it handles properties
+#
+# Note: Object.defineProperties, Object.getOwnPropertyNames, etc. technically
+#   were not part of ES5, but were implemented by IE prior to ES6, and are
+#   the only way to implement getters and setters.
+
+module Ruby2JS
+  class Converter
+
+   # (assign
+   #   target
+   #   (hash)
+   #   ...
+
+    handle :assign do |target, *args|
+      collapsible = false
+
+      nonprop = proc do |node|
+        next false unless node.is_a? Parser::AST::Node
+        next false if node.type == :pair and node.children.first.type == :prop and es2015
+        next true unless node.type == :def
+        next false if node.children.first.to_s.end_with? '='
+        node.is_method?
+      end
+
+      collapsible = true if args.length == 1 and args.first.type == :hash and
+        args.first.children.length == 1
+
+      collapsible = true if args.length == 1 and args.first.type == :class_module and
+        args.first.children.length == 3 and nonprop[args.first.children.last]
+
+      if es2015 and not collapsible and args.all? {|arg| 
+          case arg.type
+          when :pair, :hash, :class_module
+            arg.children.all? {|child| nonprop[child]}
+          when :const
+            false
+          else
+            true
+          end
+        }
+        parse s(:send, s(:const, nil, :Object), :assign, target, *args)
+      else
+
+        if target == s(:hash)
+          copy = [s(:gvasgn, :$$, target)]
+          target = s(:gvar, :$$)
+          shadow = [s(:shadowarg, :$$)]
+        elsif collapsible or es2015 or
+          (%i(send const).include? target.type and
+          target.children.length == 2 and target.children[0] == nil)
+        then
+          copy = []
+          shadow = []
+        else
+          copy = [s(:gvasgn, :$0, target)]
+          target = s(:gvar, :$0)
+          shadow = [s(:shadowarg, :$0)]
+        end
+
+        body = [*copy,
+          *args.map {|modname|
+            if modname.type == :hash and
+              modname.children.all? {|pair| pair.children.first.type == :prop}
+
+              if modname.children.length == 1
+                pair = modname.children.first
+                s(:send, s(:const, nil, :Object), :defineProperty, target, 
+                  s(:sym, pair.children.first.children.last),
+                  s(:hash, *pair.children.last.map {|name, value| s(:pair,
+                  s(:sym, name), value)}))
+              else
+                pair = modname.children.first
+                s(:send, s(:const, nil, :Object), :defineProperties, target, 
+                  s(:hash, *modname.children.map {|pair| s(:pair,
+                    s(:sym, pair.children.first.children.last),
+                    s(:hash, *pair.children.last.map {|name, value| s(:pair,
+                    s(:sym, name), value)})
+                  )}))
+              end
+
+            elsif modname.type == :hash and
+              modname.children.all? {|child| nonprop[child]}
+
+              s(:begin, *modname.children.map {|pair|
+                if pair.children.first.type == :prop
+                  s(:send, s(:const, nil, :Object), :defineProperty, target, 
+                    s(:sym, pair.children.first.children.last),
+                    s(:hash, *pair.children.last.map {|name, value| s(:pair,
+                    s(:sym, name), value)}))
+                else
+                  s(:send, target, :[]=, *pair.children)
+                end
+              })
+
+            elsif modname.type == :class_module and
+              modname.children[2..-1].all? {|child| nonprop[child]}
+
+              s(:begin, *modname.children[2..-1].map {|pair|
+                  s(:send, target, :[]=, s(:sym, pair.children.first),
+                  pair.updated(:defm, [nil, *pair.children[1..-1]]))
+                })
+
+            elsif modname.type == :lvar and not es2015
+              s(:for, s(:lvasgn, :$_), modname,
+              s(:send, target, :[]=,
+              s(:lvar, :$_), s(:send, modname, :[], s(:lvar, :$_))))
+
+            else
+              if es2017
+                s(:send, s(:const, nil, :Object), :defineProperties, target, 
+                  s(:send, s(:const, nil, :Object), :getOwnPropertyDescriptors, modname))
+              else
+                if modname.type == :lvar or (%i(send const).include? modname.type and
+                  modname.children.length == 2 and modname.children[0] == nil)
+
+                  object = modname
+                else
+                  shadow += [s(:shadowarg, :$1)]
+                  object = s(:gvar, :$1)
+                end
+
+                copy = s(:send,
+                  s(:const, nil, :Object), :defineProperties, target,
+                  s(:send,
+                    s(:send, s(:const, nil, :Object), :getOwnPropertyNames, object),
+                    :reduce,
+                    s(:block,
+                      s(:send, nil, :lambda),
+                      s(:args, s(:arg, :$2), s(:arg, :$3)),
+                      s(:begin,
+                        s(:send,
+                          s(:lvar, :$2), :[]=, s(:lvar, :$3),
+                          s(:send, s(:const, nil, :Object), :getOwnPropertyDescriptor,
+                            object, s(:lvar, :$3))),
+                        s(:return, s(:lvar, :$2)))),
+                    s(:hash)))
+
+
+                if object.type == :gvar
+                  s(:begin, s(:gvasgn, object.children.last, modname), copy)
+                else
+                  copy
+                end
+              end
+            end
+          }]
+
+        if @state == :statement and shadow.empty?
+          parse s(:begin, *body)
+        else
+          body.push s(:return, target) if @state == :expression
+          parse s(:send, s(:block, s(:send, nil, :lambda), s(:args, *shadow),
+            s(:begin, *body)), :[])
+        end
+      end
+    end
+  end
+end