ruby2js 3.6.1 → 4.0.0

data/lib/ruby2js/converter/vasgn.rb

@@ -8,6 +8,11 @@ module Ruby2JS
     #   (int 1))
 
     handle :lvasgn, :gvasgn do |name, value=nil|
+      if @ast.type == :lvasgn and value
+        receiver = @rbstack.map {|rb| rb[name]}.compact.last
+        return parse s(:attr, receiver, "#{name}=", value) if receiver
+      end
+
       state  = @state
       begin
         if value and value.type == :lvasgn and @state == :statement

data/lib/ruby2js/demo.rb

@@ -0,0 +1,53 @@
+# helper methods shared between MRI CGI/server and Opal implementations
+require 'ruby2js'
+
+module Ruby2JS
+  module Demo
+    def self.parse_autoimports(mappings)
+      autoimports = {}
+
+      mappings = mappings.gsub(/\s+|"|'/, '')
+
+      while mappings and not mappings.empty?
+        if mappings =~ /^(\w+):([^,]+)(,(.*))?$/
+          # symbol: module
+          autoimports[$1.to_sym] = $2
+          mappings = $4
+        elsif mappings =~ /^\[([\w,]+)\]:([^,]+)(,(.*))?$/
+          # [symbol, symbol]: module
+          mname, mappings = $2, $4
+          autoimports[$1.split(/,/).map(&:to_sym)] = mname
+        elsif mappings =~ /^(\w+)(,(.*))?$/
+          # symbol
+          autoimports[$1.to_sym] = $1
+          mappings = $3
+        elsif not mappings.empty?
+          $load_error = "unsupported autoimports mapping: #{mappings}"
+          mappings = ''
+        end
+      end
+
+      # if nothing is listed, provide a mapping for everything
+      autoimports = proc {|name| name.to_s} if autoimports.empty?
+
+      autoimports
+    end
+
+    def self.parse_defs(mappings)
+      defs = {}
+
+      mappings = mappings.gsub(/\s+|"|'/, '')
+
+      while mappings =~ /^(\w+):\[(:?@?\w+(,:?@?\w+)*)\](,(.*))?$/
+        mappings = $5
+        defs[$1.to_sym] = $2.gsub(':', '').split(',').map(&:to_sym)
+      end
+
+      if mappings and not mappings.empty?
+        $load_error = "unsupported defs: #{mappings}"
+      end
+
+      defs
+    end
+  end
+end

data/lib/ruby2js/es2022.rb

@@ -0,0 +1,5 @@
+require 'ruby2js'
+
+if Ruby2JS.eslevel_default < 2022
+  Ruby2JS.eslevel_default = 2022
+end

data/lib/ruby2js/es2022/strict.rb

@@ -0,0 +1,3 @@
+require 'ruby2js/es2022'
+
+Ruby2JS.strict_default = true

data/lib/ruby2js/filter.rb

@@ -13,6 +13,14 @@ module Ruby2JS
     @@included = nil
     @@excluded = []
 
+    def self.included_methods
+      @@included&.dup
+    end
+
+    def self.excluded_methods
+      @@excluded&.dup
+    end
+
     # indicate that the specified methods are not to be processed
     def self.exclude(*methods)
       if @@included
@@ -52,7 +60,7 @@ module Ruby2JS
         not @included.include? method
       else
         return true if @exclude_methods.flatten.include? method
-        @excluded.include? method
+        @excluded&.include? method
       end
     end
 

data/lib/ruby2js/filter/active_functions.rb

@@ -7,6 +7,7 @@ module Ruby2JS
 
       def on_send(node)
         target, method, *args = node.children
+        return super unless args.empty?
 
         if es2015 and method == :blank?
           create_or_update_import("blank$")

data/lib/ruby2js/filter/cjs.rb

@@ -1,5 +1,7 @@
 require 'ruby2js'
 
+Ruby2JS.module_default ||= :cjs
+
 module Ruby2JS
   module Filter
     module CJS

data/lib/ruby2js/filter/esm.rb

@@ -9,20 +9,21 @@ module Ruby2JS
 
       def options=(options)
         super
-        @esm_autoexports = options[:autoexports] && !@disable_autoexports
+        @esm_autoexports = !@disable_autoexports && options[:autoexports]
         @esm_autoimports = options[:autoimports]
+        @esm_defs = options[:defs] || {}
         @esm_explicit_tokens = Set.new
       end
 
       def process(node)
         return super unless @esm_autoexports
-        @esm_autoexports = false
 
         list = [node]
         while list.length == 1 and list.first.type == :begin
           list = list.first.children.dup
         end
 
+        replaced = []
         list.map! do |child|
           replacement = child
 
@@ -37,13 +38,27 @@ module Ruby2JS
             replacement = s(:export, child)
           end
 
-          if replacement != child and @comments[child]
-            @comments[replacement] = @comments[child]
+          if replacement != child
+            replaced << replacement
+            @comments[replacement] = @comments[child] if @comments[child]
           end
 
           replacement
         end
 
+        if replaced.length == 1 and @esm_autoexports == :default
+          list.map! do |child|
+            if child == replaced.first
+              replacement = s(:export, s(:send, nil, :default, *child.children))
+              @comments[replacement] = @comments[child] if @comments[child]
+              replacement
+            else
+              child
+            end
+          end
+        end
+
+        @esm_autoexports = false
         process s(:begin, *list)
       end
 
@@ -78,7 +93,7 @@ module Ruby2JS
             end
           end
 
-          if args[0].type == :str
+          if args[0].type == :str and args.length == 1
             # import "file.css"
             #   => import "file.css"
             s(:import, args[0].children[0])
@@ -106,15 +121,20 @@ module Ruby2JS
             #   => import Stuff as * from "file.js"
             # import [ Some, Stuff ], from: "file.js"
             #   => import { Some, Stuff } from "file.js"
-            imports = if args[0].type == :const || args[0].type == :send
+            # import Some, [ More, Stuff ], from: "file.js"
+            #   => import Some, { More, Stuff } from "file.js"
+            imports = []
+            if %i(const send str).include? args[0].type
               @esm_explicit_tokens << args[0].children.last
-              process(args[0])
-            else
+              imports << process(args.shift)
+            end
+
+            if args[0].type == :array
               args[0].children.each {|i| @esm_explicit_tokens << i.children.last}
-              process_all(args[0].children)
+              imports << process_all(args.shift.children)
             end
 
-            s(:import, args[1].children, imports) unless args[1].nil?
+            s(:import, args[0].children, *imports) unless args[0].nil?
           end
         elsif method == :export          
           s(:export, *process_all(args))
@@ -129,6 +149,20 @@ module Ruby2JS
       def on_const(node)
         if node.children.first == nil and found_import = find_autoimport(node.children.last)
           prepend_list << s(:import, found_import[0], found_import[1])
+
+          values = @esm_defs[node.children.last]
+          
+	  if values
+	    values = values.map {|value| 
+	      if value.to_s.start_with? "@" 
+		[value.to_s[1..-1].to_sym, s(:self)]
+	      else
+		[value.to_sym, s(:autobind, s(:self))]
+	      end
+	    }.to_h
+
+	    @namespace.defineProps values, [node.children.last]
+	  end
         end
 
         super

data/lib/ruby2js/filter/functions.rb

@@ -1,5 +1,5 @@
 require 'ruby2js'
-require 'regexp_parser'
+require 'regexp_parser/scanner'
 
 module Ruby2JS
   module Filter
@@ -49,71 +49,78 @@ module Ruby2JS
 
         elsif method == :[]= and args.length == 3 and
           args[0].type == :regexp and args[1].type == :int
+
           index = args[1].children.first
 
-          parts = Regexp::Parser.parse(args[0].children.first.children.first)
-          split = parts.index do |part|
-            part.type == :group and part.number == index
+          # identify groups
+          regex = args[0].children.first.children.first
+          tokens = Regexp::Scanner.scan(regex)
+          groups = []
+          stack = []
+          tokens.each do |token|
+            next unless token[0] == :group
+            if token[1] == :capture
+              groups.push token.dup
+              return super if groups.length == index and not stack.empty?
+              stack.push groups.last
+            elsif token[1] == :close
+              stack.pop[-1]=token.last
+            end
           end
+          group = groups[index-1]
 
-          return super unless split
+          # rewrite regex
+          prepend = nil
+          append = nil
 
-          rewritten = parts[split].to_s
-
-          dstr = [args.last]
-          if rewritten == '()'
-            index -= 1
-            rewritten = ''
+          if group[4] < regex.length
+            regex = (regex[0...group[4]] + '(' + regex[group[4]..-1] + ')').
+              sub(/\$\)$/, ')$')
+            append = 2
           end
 
-          parts = parts.to_a
-
-          pre = ''
-          if parts.first.type == :anchor
-            pre = parts.shift.to_s
-            split -= 1
+          if group[4] - group[3] == 2
+            regex = regex[0...group[3]] + regex[group[4]..-1]
+            append = 1 if append
           end
 
-          if split > 0
-            if split == 1 and parts.first.type == :group
-              rewritten = parts.first.to_s + rewritten
-            else
-              rewritten = '(' + parts[0 .. split - 1].join + ')' + rewritten
-              index += 1
-            end
-            dstr.unshift s(:send, s(:lvar, :match), :[], s(:int, 0))
+          if group[3] > 0
+            regex = ('(' + regex[0...group[3]] + ')' + regex[group[3]..-1]).
+              sub(/^\(\^/, '^(')
+            prepend = 1
+            append += 1 if append
           end
 
+          regex = process s(:regexp, s(:str, regex), args[0].children.last)
 
-          post = ''
-          if parts.last.type == :anchor
-            post = parts.pop.to_s
-          end
-
-          if split + 1 < parts.length
-            if split  + 2 == parts.length and parts.last.type == :group
-              rewritten += parts.last.to_s
-            else
-              rewritten += '(' + parts[split + 1 .. -1].join + ')'
+          # 
+          if args.last.type == :str
+            str = args.last.children.first.gsub('$', '$$')
+            str = "$#{prepend}#{str}" if prepend
+            str = "#{str}$#{append}" if append
+            expr = s(:send, target, :replace, regex, s(:str, str))
+          else
+            dstr = args.last.type == :dstr ? args.last.children.dup : [args.last]
+            if prepend
+              dstr.unshift s(:send, s(:lvar, :match), :[], s(:int, prepend-1))
+            end
+            if append
+              dstr << s(:send, s(:lvar, :match), :[], s(:int, append-1))
             end
-            dstr << s(:send, s(:lvar, :match), :[], s(:int, index))
-          end
-
-          rewritten = pre + rewritten + post
 
-          regex = process s(:regexp, s(:str, rewritten), args[0].children.last)
-          block = s(:block,
-            s(:send, target, :replace, regex),
-            s(:args, s(:arg, :match)),
-            process(s(:dstr, *dstr)))
+            expr = s(:block,
+              s(:send, target, :replace, regex),
+              s(:args, s(:arg, :match)),
+              process(s(:dstr, *dstr)))
+          end
 
           if VAR_TO_ASSIGN.keys.include? target.type
-            S(VAR_TO_ASSIGN[target.type], target.children.first, block)
+            S(VAR_TO_ASSIGN[target.type], target.children.first, expr)
           elsif target.type == :send
             if target.children[0] == nil
-              S(:lvasgn, target.children[1], block)
+              S(:lvasgn, target.children[1], expr)
             else
-              S(:send, target.children[0], :"#{target.children[1]}=", block)
+              S(:send, target.children[0], :"#{target.children[1]}=", expr)
             end
           else
             super
@@ -122,57 +129,14 @@ module Ruby2JS
         elsif method == :merge
           args.unshift target
 
-          if es2015
-            if es2018
-              process S(:hash, *args.map {|arg| s(:kwsplat, arg)})
-            else
-              process S(:send, s(:const, nil, :Object), :assign, s(:hash),
-                *args)
-            end
+          if es2018
+            process S(:hash, *args.map {|arg| s(:kwsplat, arg)})
           else
-            copy = [s(:gvasgn, :$$, s(:hash))]
-
-            s(:send, s(:block, s(:send, nil, :lambda), s(:args),
-              s(:begin, *copy, *args.map {|modname|
-              if modname.type == :hash
-                s(:begin, *modname.children.map {|pair|
-                    s(:send, s(:gvar, :$$), :[]=, *pair.children)
-                  })
-              else
-                s(:for, s(:lvasgn, :$_), modname,
-                s(:send, s(:gvar, :$$), :[]=,
-                s(:lvar, :$_), s(:send, modname, :[], s(:lvar, :$_))))
-              end
-              }, s(:return, s(:gvar, :$$)))), :[])
+            process S(:assign, s(:hash), *args)
           end
 
         elsif method == :merge!
-          if es2015
-            process S(:send, s(:const, nil, :Object), :assign, target, *args)
-          else
-            copy = []
-
-            unless
-               target.type == :send and target.children.length == 2 and
-               target.children[0] == nil
-            then
-               copy << s(:gvasgn, :$0, target)
-               target = s(:gvar, :$0)
-            end
-
-            s(:send, s(:block, s(:send, nil, :lambda), s(:args),
-              s(:begin, *copy, *args.map {|modname|
-              if modname.type == :hash
-                s(:begin, *modname.children.map {|pair|
-                    s(:send, target, :[]=, *pair.children)
-                  })
-              else
-                s(:for, s(:lvasgn, :$_), modname,
-                s(:send, target, :[]=,
-                s(:lvar, :$_), s(:send, modname, :[], s(:lvar, :$_))))
-              end
-              }, s(:return, target))), :[])
-          end
+          process S(:assign, target, *args)
 
         elsif method == :delete and args.length == 1
           if not target
@@ -551,6 +515,20 @@ module Ruby2JS
             s(:args, s(:arg, :a), s(:arg, :b)),
             s(:send, s(:lvar, :a), :+, s(:lvar, :b))), s(:int, 0))
 
+        elsif method == :method_defined? and args.length >= 1
+          if args[1] == s(:false)
+            process S(:send, s(:attr, target, :prototype), :hasOwnProperty, args[0])
+          elsif args.length == 1 or args[1] == s(:true)
+            process S(:in?, args[0], s(:attr, target, :prototype))
+          else
+            process S(:if, args[1], s(:in?, args[0], s(:attr, target, :prototype)),
+              s(:send, s(:attr, target, :prototype), :hasOwnProperty, args[0]))
+          end
+
+        elsif method == :alias_method and args.length == 2
+          process S(:send, s(:attr, target, :prototype), :[]=, args[0],
+            s(:attr, s(:attr, target, :prototype), args[1].children[0]))
+
         else
           super
         end
@@ -737,6 +715,10 @@ module Ruby2JS
             s(:return, s(:lvar, node.children[1].children[0].children[0])))),
             :[], call.children[0]])
 
+        elsif method == :define_method and call.children.length == 3
+          process node.updated(:send, [s(:attr, call.children[0], :prototype), :[]=,
+            call.children[2], s(:deff, nil, *node.children[1..-1])])
+
         else
           super
         end
@@ -746,6 +728,12 @@ module Ruby2JS
         name, inheritance, *body = node.children
         body.compact!
 
+        body.each_with_index do |node, i|
+          if node.type == :send and node.children[0..1] == [nil, :alias_method]
+            body[i] = node.updated(:send, [name, *node.children[1..-1]])
+          end
+        end
+
         if inheritance == s(:const, nil, :Exception)
           unless
             body.any? {|statement| statement.type == :def and
@@ -761,7 +749,8 @@ module Ruby2JS
           body = [s(:begin, *body)] if body.length > 1
           S(:class, name, s(:const, nil, :Error), *body)
         else
-          super
+          body = [s(:begin, *body)] if body.length > 1
+          super S(:class, name, inheritance, *body)
         end
       end
     end