ruby2js 3.6.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11ab4e0003f0ff4f5821c00d5e282dead1201f97d4a2cc9ffb5c1188687f6079
-  data.tar.gz: fe572bef6b5ee55d46d72bb71dfcca5793fff8dd29a44243da637a7b91264bf7
+  metadata.gz: 064d9dc5d65f6e2456e91d951e2f4311b776221422a77d59a8cfd466ceb5056d
+  data.tar.gz: ffc274a55ceb9a1280f776c00da8c296dc10672150174135931547cd056a3520
 SHA512:
-  metadata.gz: f865febd41bda90440a03b5ccdb7ac921eb794701c61d120b28a850d03001ee95ae0403bd50123d96c0f85b5e3a0e672066fcde7da68216c28f6f5895b2f9398
-  data.tar.gz: cf4811376c6daf78e951f688b6b2ee78e1b627135ed365e7197a6a318601b8b6313d2c4123031fd395cf5342707914e56bc29d946e15dc8f1dc7d53d35b053c6
+  metadata.gz: 8fe9775803716fce25697adaf59a8afb57f4de499052a66847f18dfdd59c1f73b52d77be473adf762a57693a0896a6c90ed275a2b9152b5b6b548ca454e6d9ae
+  data.tar.gz: aa901eab47bba051a69a0ee132b69e7754aa5da49ff2e7e22560303a4c0fd02cdb727d4297c13098f3a6f82cf20788f4657c7ec21d145e66533875933d1a5154

data/README.md

@@ -13,7 +13,7 @@ Documentation
 
 * Visit **[ruby2js.com](https://www.ruby2js.com)** for detailed setup instructions and API reference.
 
-* [Try Ruby2JS online](https://whimsy.apache.org/ruby2js)
+* [Try Ruby2JS online](https://ruby2js.com/demo)
 
 
 Synopsis
@@ -39,12 +39,6 @@ Host variable substitution:
  puts Ruby2JS.convert("@name", ivars: {:@name => "Joe"})
 ```
 
-Host expression evalution -- potentially unsafe, use only if you trust
-the source being converted::
-```ruby
- i = 7; puts Ruby2JS.convert("i = `i`", binding: binding)
-```
-
 Enable ES2015 support:
 
 ```ruby

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,7 +67,7 @@ module Ruby2JS
       include Ruby2JS::Filter
       BINARY_OPERATORS = Converter::OPERATORS[2..-1].flatten
 
-      attr_accessor :prepend_list, :disable_autoimports
+      attr_accessor :prepend_list, :disable_autoimports, :namespace
 
       def initialize(comments)
         @comments = comments
@@ -79,8 +85,8 @@ module Ruby2JS
       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]
@@ -116,6 +122,10 @@ module Ruby2JS
         @options[:eslevel] >= 2021
       end
 
+      def es2022
+        @options[:eslevel] >= 2022
+      end
+
       def process(node)
         ast, @ast = @ast, node
         replacement = super
@@ -130,6 +140,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
@@ -137,18 +148,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
@@ -178,6 +194,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
@@ -197,6 +214,8 @@ module Ruby2JS
       comments = ast ? Parser::Source::Comment.associate(ast, comments) : {}
     end
 
+    namespace = Namespace.new
+
     filters = (options[:filters] || Filter::DEFAULTS)
 
     unless filters.empty?
@@ -211,6 +230,7 @@ module Ruby2JS
       filter = filter.new(comments)
 
       filter.options = options
+      filter.namespace = namespace
       ast = filter.process(ast)
 
       unless filter.prepend_list.empty?
@@ -229,7 +249,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)]}]'
@@ -256,16 +279,16 @@ module Ruby2JS
     buffer = Parser::Source::Buffer.new(file, line)
     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()
@@ -160,6 +160,10 @@ module Ruby2JS
       @eslevel >= 2021
     end
 
+    def es2022
+      @eslevel >= 2022
+    end
+
     @@handlers = []
     def self.handle(*types, &block)
       types.each do |type| 
@@ -295,6 +299,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 +319,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'

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

data/lib/ruby2js/converter/begin.rb

@@ -9,6 +9,11 @@ module Ruby2JS
       state = @state
       props = false
 
+      if state == :expression and statements.empty?
+        puts 'null'
+        return
+      end
+
       statements.map! do |statement|
         case statement and statement.type
         when :defs, :defp
@@ -32,9 +37,9 @@ module Ruby2JS
     end
 
     def combine_properties(body)
-      for i in 0...body.length-1
+      (0...body.length-1).each do |i|
         next unless body[i] and body[i].type == :prop
-        for j in i+1...body.length
+        (i+1...body.length).each do |j|
           break unless body[j] and body[j].type == :prop
 
           if body[i].children[0] == body[j].children[0]

data/lib/ruby2js/converter/case.rb

@@ -10,10 +10,15 @@ module Ruby2JS
 
     handle :case do |expr, *whens, other|
       begin
+        if @state == :expression
+          parse s(:kwbegin, @ast), @state
+          return
+        end
+
         inner, @inner = @inner, @ast
 
         has_range = whens.any? do |node| 
-          node.children.any? {|child| [:irange, :erange].include? child.type}
+          node.children.any? {|child| [:irange, :erange].include? child&.type}
         end
 
         if has_range
@@ -47,7 +52,7 @@ module Ruby2JS
 
           parse code, :statement
           last = code
-          while last.type == :begin
+          while last&.type == :begin
             last = last.children.last
           end
 

data/lib/ruby2js/converter/class.rb

@@ -11,13 +11,27 @@ module Ruby2JS
     # NOTE: class_extend is not generated by the parser, but instead produced
     #       when ++class is encountered; it signals that this construct is
     #       meant to extend an already existing JavaScrpt class.
+    #
+    #       class_hash is an anonymous class as a value in a hash; the
+    #       name has already been output so should be ignored other than
+    #       in determining the namespace.
+    #
+    #       class_module is a module that to be re-processed by this handler
+    #       given the similarity between the two structures.
 
-    handle :class, :class_extend, :class_module do |name, inheritance, *body|
-      if @ast.type != :class
+    handle :class, :class_hash, :class_extend, :class_module do |name, inheritance, *body|
+      extend = @namespace.enter(name) unless @ast.type == :class_module
+
+      if !%i(class class_hash).include?(@ast.type) or extend
         init = nil
       else
-        if es2015
-          parse @ast.updated(:class2)
+        if es2015 and not extend
+          if @ast.type == :class_hash
+            parse @ast.updated(:class2, [nil, *@ast.children[1..-1]])
+          else
+            parse @ast.updated(:class2)
+          end
+          @namespace.leave unless @ast.type == :class_module
           return
         end
 
@@ -35,7 +49,7 @@ module Ruby2JS
       end
 
       body.compact!
-      visible = {}
+      visible = @namespace.getOwnProps
       body.map! do |m| 
         if \
           @ast.type == :class_module and m.type == :defs and
@@ -45,7 +59,7 @@ module Ruby2JS
         end
 
         node = if m.type == :def
-          if m.children.first == :initialize
+          if m.children.first == :initialize and !visible[:initialize]
             # constructor: remove from body and overwrite init function
             init = m
             nil
@@ -54,17 +68,20 @@ module Ruby2JS
             sym = :"#{m.children.first.to_s[0..-2]}"
             s(:prop, s(:attr, name, :prototype), sym =>
                 {enumerable: s(:true), configurable: s(:true),
-                set: s(:block, s(:send, nil, :proc), *m.children[1..-1])})
+                set: s(:defm, nil, *m.children[1..-1])})
           else
-            visible[m.children[0]] = s(:self)
 
             if not m.is_method?
+              visible[m.children[0]] = s(:self)
+
               # property getter
               s(:prop, s(:attr, name, :prototype), m.children.first =>
                   {enumerable: s(:true), configurable: s(:true),
-                  get: s(:block, s(:send, nil, :proc), m.children[1],
+                  get: s(:defm, nil, m.children[1],
                     m.updated(:autoreturn, m.children[2..-1]))})
             else
+              visible[m.children[0]] = s(:autobind, s(:self))
+
               # method: add to prototype
               s(:method, s(:attr, name, :prototype),
                 :"#{m.children[0].to_s.chomp('!')}=",
@@ -90,7 +107,7 @@ module Ruby2JS
           else
             # class method definition: add to prototype
             s(:prototype, s(:send, name, "#{m.children[1]}=",
-              s(:block, s(:send, nil, :proc), *m.children[2..-1])))
+              s(:defm, nil, *m.children[2..-1])))
           end
 
         elsif m.type == :send and m.children.first == nil
@@ -125,9 +142,10 @@ module Ruby2JS
           elsif m.children[1] == :include
             s(:send, s(:block, s(:send, nil, :lambda), s(:args),
               s(:begin, *m.children[2..-1].map {|modname|
-              s(:for, s(:lvasgn, :$_), modname,
-              s(:send, s(:attr, name, :prototype), :[]=,
-              s(:lvar, :$_), s(:send, modname, :[], s(:lvar, :$_))))
+                @namespace.defineProps @namespace.find(modname)
+                s(:for, s(:lvasgn, :$_), modname,
+                s(:send, s(:attr, name, :prototype), :[]=,
+                s(:lvar, :$_), s(:send, modname, :[], s(:lvar, :$_))))
               })), :[])
           elsif [:private, :protected, :public].include? m.children[1]
             raise Error.new("class #{m.children[1]} is not supported", @ast)
@@ -160,17 +178,23 @@ module Ruby2JS
           s(:send, s(:attr, name, :prototype),
             "#{m.children[0].children.first}=", 
             s(:attr, s(:attr, name, :prototype), m.children[1].children.first))
-        elsif m.type == :class
+        elsif m.type == :class or m.type == :module
           innerclass_name = m.children.first
           if innerclass_name.children.first
             innerclass_name = innerclass_name.updated(nil,
-              [s(:attr, innerclass_name.children[0], name),
+              [s(:attr, name, innerclass_name.children[0].children.last),
               innerclass_name.children[1]])
           else
             innerclass_name = innerclass_name.updated(nil,
               [name, innerclass_name.children[1]])
           end
           m.updated(nil, [innerclass_name, *m.children[1..-1]])
+        elsif @ast.type == :class_module
+          m
+        elsif m.type == :defineProps
+          @namespace.defineProps m.children.first
+          visible.merge! m.children.first
+          nil
         else
           raise Error.new("class #{ m.type } not supported", @ast)
         end
@@ -194,7 +218,7 @@ module Ruby2JS
       # merge property definitions
       combine_properties(body)
 
-      if inheritance
+      if inheritance and (@ast.type != :class_extend and !extend)
         body.unshift s(:send, name, :prototype=, 
           s(:send, s(:const, nil, :Object), :create,
             s(:attr, inheritance, :prototype))),
@@ -206,10 +230,14 @@ module Ruby2JS
         methods = 0
         start = 0
         body.each do |node|
-          if [:method, :prop].include? node.type and 
+          if (node.type == :method or (node.type == :prop and es2015)) and
             node.children[0].type == :attr and
             node.children[0].children[1] == :prototype
             methods += 1
+          elsif node.type == :class and @ast.type == :class_module and es2015
+            methods += 1 if node.children.first.children.first == name
+          elsif node.type == :module and @ast.type == :class_module
+            methods += 1 if node.children.first.children.first == name
           elsif methods == 0
             start += 1
           else
@@ -219,14 +247,22 @@ module Ruby2JS
 
         # collapse sequence to a single assignment
         if \
-          @ast.type != :class_extend and
-          (methods > 1 or (methods == 1 and body[start].type == :prop))
+          @ast.type == :class_module or methods > 1 or 
+          body[start]&.type == :prop
         then
           pairs = body[start...start+methods].map do |node|
             if node.type == :method
               replacement = node.updated(:pair, [
                 s(:str, node.children[1].to_s.chomp('=')),
                 node.children[2]])
+            elsif node.type == :class and node.children.first.children.first == name
+              sym = node.children.first.children.last
+              replacement = s(:pair, s(:sym, sym),
+                s(:class_hash, s(:const, nil, sym), nil, node.children.last))
+            elsif node.type == :module and node.children.first.children.first == name
+              sym = node.children.first.children.last
+              replacement = s(:pair, s(:sym, sym),
+                s(:module_hash, s(:const, nil, sym), node.children.last))
             else
               replacement = node.children[1].map do |prop, descriptor|
                 node.updated(:pair, [s(:prop, prop), descriptor])
@@ -244,12 +280,30 @@ module Ruby2JS
           end
 
           if @ast.type == :class_module
+            start = 0 if methods == 0
+            if name
+              body[start...start+methods] =
+                s(:casgn, *name.children, s(:hash, *pairs.flatten))
+            else
+              body[start...start+methods] = s(:hash, *pairs.flatten)
+            end
+          elsif @ast.type == :class_extend or extend
             body[start...start+methods] =
-              s(:casgn, *name.children, s(:hash, *pairs.flatten))
+              s(:assign, body[start].children.first, s(:hash, *pairs.flatten))
           else
             body[start...start+methods] =
               s(:send, name, :prototype=, s(:hash, *pairs.flatten))
           end
+
+        elsif (@ast.type == :class_extend or extend) and methods > 1
+
+          pairs = body[start...start+methods].map do |node|
+            node.updated(:pair, [
+               s(:sym, node.children[1].to_s[0..-2]), node.children[2]])
+          end
+
+          body[start...start+methods] =
+            s(:assign, body[start].children.first, s(:hash, *pairs))
         end
       end
 
@@ -258,7 +312,7 @@ module Ruby2JS
         constructor = init.updated(:constructor, [name, *init.children[1..-1]])
         @comments[constructor] = @comments[init] unless @comments[init].empty?
 
-        if @ast.type == :class_extend
+        if @ast.type == :class_extend or extend
           if es2015
             constructor = s(:masgn, s(:mlhs, 
               s(:attr, s(:casgn, *name.children, constructor), :prototype)), 
@@ -285,6 +339,7 @@ module Ruby2JS
 
         # add locally visible interfaces to rbstack.  See send.rb, const.rb
         @rbstack.push visible
+        @rbstack.last.merge!(@namespace.find(inheritance)) if inheritance
 
         parse s(:begin, *body.compact), :statement
       ensure
@@ -292,6 +347,7 @@ module Ruby2JS
         @class_name = class_name
         @class_parent = class_parent
         @rbstack.pop
+        @namespace.leave unless @ast.type == :class_module
       end
     end