ruby2js 3.3.4 → 3.5.1

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

@@ -6,63 +6,58 @@ module Ruby2JS
       include SEXP
 
       def initialize(*args)
-        @esm_include = nil
         super
+        @esm = true # signal for other filters
       end
 
-      def process(node)
-        return super if @esm_include
-        @esm_include = Set.new
-        @esm_exclude = Set.new
-        @esm_export = nil
-        result = super
+      def on_send(node)
+        target, method, *args = node.children
+        return super unless target.nil?
 
-        esm_walk(result)
-
-        inventory = (@esm_include - @esm_exclude).to_a.sort
-
-        if inventory.empty? and not @esm_export
-          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
+        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
 
-          list.push result
+          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])))
 
-          if @esm_export
-            list.push s(:export, :default, s(:const, nil, @esm_export))
+          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
-
-          s(:begin, *list.compact)
-        end
-      end
-
-      # 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
-          end
-        end
-
-        # recurse
-        node.children.each do |child|
-          esm_walk(child) if Parser::AST::Node === child
+        elsif method == :export          
+          s(:export, *process_all(args))
+        else
+          super
         end
       end
     end

data/lib/ruby2js/filter/esm_migration.rb

@@ -0,0 +1,72 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module ESMMigration
+      include SEXP
+
+      def initialize(*args)
+        @esm_include = nil
+        super
+      end
+
+      def process(node)
+        return super if @esm_include
+        @esm_include = Set.new
+        @esm_exclude = Set.new
+        @esm_export = nil
+        result = super
+
+        esm_walk(result)
+
+        inventory = (@esm_include - @esm_exclude).to_a.sort
+
+        if inventory.empty? and not @esm_export
+          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
+
+          list.push result
+
+          if @esm_export
+            list.push s(:export, :default, s(:const, nil, @esm_export))
+          end
+
+          s(:begin, *list.compact)
+        end
+      end
+
+      # 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
+          end
+        end
+
+        # recurse
+        node.children.each do |child|
+          esm_walk(child) if Parser::AST::Node === child
+        end
+      end
+    end
+
+    DEFAULTS.push ESMMigration
+  end
+end

data/lib/ruby2js/filter/fast-deep-equal.rb

@@ -0,0 +1,23 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module Fast_Deep_Equal
+      include SEXP
+
+      SCALAR = [ :float, :int, :nil, :str ]
+
+      def on_send(node)
+        return super unless node.children.length == 3
+        left, method, right = node.children
+        return super unless method == :==
+        return super if SCALAR.include? left.type
+        return super if SCALAR.include? right.type
+
+        node.updated nil, [nil, :$eq, left, right]
+      end
+    end
+
+    DEFAULTS.push Fast_Deep_Equal
+  end
+end