ruby2js 4.1.4 → 4.2.0

data/lib/ruby2js/converter/logical.rb

@@ -69,16 +69,16 @@ module Ruby2JS
         left = rewrite(*left.children)
       end
 
-      if right.type != :send
+      if right.type != :send or OPERATORS.flatten.include? right.children[1]
         s(:and, left, right)
       elsif conditionally_equals(left, right.children.first)
         # a && a.b => a&.b
-        right.updated(:csend, [left, right.children.last])
+        right.updated(:csend, [left, *right.children[1..-1]])
       elsif conditionally_equals(left.children.last, right.children.first)
         # a && b && b.c => a && b&.c
         left.updated(:and, [left.children.first,
           left.children.last.updated(:csend, 
-          [left.children.last, right.children.last])])
+          [left.children.last, *right.children[1..-1]])])
       else
         s(:and, left, right)
       end

data/lib/ruby2js/converter/return.rb

@@ -15,7 +15,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, :taglit, :self,
-      :op_asgn, :and_asgn, :or_asgn, :taglit, :gvar ]
+      :op_asgn, :and_asgn, :or_asgn, :taglit, :gvar, :csend ]
 
     handle :autoreturn do |*statements|
       return if statements == [nil]

data/lib/ruby2js/converter.rb

@@ -17,8 +17,8 @@ module Ruby2JS
 
     LOGICAL   = :and, :not, :or
     OPERATORS = [:[], :[]=], [:not, :!], [:**], [:*, :/, :%], [:+, :-], 
-      [:>>, :<<], [:&], [:^, :|], [:<=, :<, :>, :>=], [:==, :!=, :===, :"!=="],
-      [:and, :or]
+      [:>>, :<<], [:&], [:^, :|], [:<=, :<, :>, :>=],
+      [:==, :!=, :===, :"!==", :=~, :!~], [:and, :or]
     
     INVERT_OP = {
       :<  => :>=,

data/lib/ruby2js/demo.rb

@@ -3,6 +3,34 @@ require 'ruby2js'
 
 module Ruby2JS
   module Demo
+    # convert {"[:foo, :Bar]" => "wee"} to {[:foo, :Bar] => "wee"}
+    def self.parse_stringified_symbol_keys(mapping_hash)
+      updated_mappings = {}
+
+      mapping_hash.each do |k, v|
+        next updated_mappings[k] = v unless k.is_a?(String) && k.start_with?("[:")
+      
+        new_k = k.tr("[]", "").split(",").map! {|str| str.strip.delete_prefix(":").to_sym }.map(&:to_sym)
+        updated_mappings[new_k] = v
+      end
+
+      updated_mappings
+    end
+
+    # convert {"Foo" => "[:bar, :Baz]"} to {"Foo" => [:bar, :Baz]}
+    def self.parse_stringified_symbol_values(mapping_hash)
+      updated_mappings = {}
+
+      mapping_hash.each do |k, v|
+        next updated_mappings[k] = v unless v.is_a?(String) && v.start_with?("[:")
+      
+        new_v = v.tr("[]", "").split(",").map! {|str| str.strip.delete_prefix(":").to_sym }.map(&:to_sym)
+        updated_mappings[k] = new_v
+      end
+
+      updated_mappings
+    end
+
     def self.parse_autoimports(mappings)
       autoimports = {}
 

data/lib/ruby2js/filter/active_functions.rb

@@ -7,7 +7,6 @@ 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$")
@@ -18,6 +17,15 @@ module Ruby2JS
         elsif es2015 and method == :presence
           create_or_update_import("presence$")
           process node.updated :send, [nil, "presence$", target]
+        elsif es2015 and method == :chomp
+          create_or_update_import("chomp$")
+          process node.updated :send, [nil, "chomp$", target, *args]
+        elsif es2015 and method == :delete_prefix
+          create_or_update_import("deletePrefix$")
+          process node.updated :send, [nil, "deletePrefix$", target, *args]
+        elsif es2015 and method == :delete_suffix
+          create_or_update_import("deleteSuffix$")
+          process node.updated :send, [nil, "deleteSuffix$", target, *args]
         else
           super
         end

data/lib/ruby2js/filter/camelCase.rb

@@ -69,7 +69,7 @@ module Ruby2JS
       def handle_generic_node(node, node_type)
         return node if node.type != node_type
 
-        if node.children[0] =~ /_.*\w$/ and !ALLOWLIST.include?(node.children[0].to_s)
+        if node.children[0] =~ /_.*[?!\w]$/ and !ALLOWLIST.include?(node.children[0].to_s)
           S(node_type , camelCase(node.children[0]), *node.children[1..-1])
         else
           node
@@ -136,7 +136,7 @@ module Ruby2JS
         node = super
         return node if node.type != :defs
 
-        if node.children[1] =~ /_.*\w$/
+        if node.children[1] =~ /_.*[?!\w]$/
           S(:defs , node.children[0],
             camelCase(node.children[1]), *node.children[2..-1])
         else

data/lib/ruby2js/filter/esm.rb

@@ -13,16 +13,30 @@ module Ruby2JS
         @esm_autoimports = options[:autoimports]
         @esm_defs = options[:defs] || {}
         @esm_explicit_tokens = Set.new
+        @esm_top = nil
+
+        # don't convert requires if Require filter is included
+        filters = options[:filters] || Filter::DEFAULTS
+        if \
+          defined? Ruby2JS::Filter::Require and
+          filters.include? Ruby2JS::Filter::Require
+        then
+          @esm_top = []
+        end
       end
 
       def process(node)
-        return super unless @esm_autoexports
+        return super if @esm_top
 
         list = [node]
         while list.length == 1 and list.first.type == :begin
           list = list.first.children.dup
         end
 
+        @esm_top = list
+
+        return super unless @esm_autoexports
+
         replaced = []
         list.map! do |child|
           replacement = child
@@ -84,7 +98,7 @@ module Ruby2JS
         target, method, *args = node.children
         return super unless target.nil?
 
-        if method == :import
+        if method == :import or (method == :require and @esm_top&.include? @ast)
           # don't do the conversion if the word import is followed by a paren
           if node.loc.respond_to? :selector
             selector = node.loc.selector
@@ -98,7 +112,7 @@ module Ruby2JS
             #   => import "file.css"
             s(:import, args[0].children[0])
           elsif args.length == 1 and \
-             args[0].type == :send 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 \
@@ -152,17 +166,17 @@ module Ruby2JS
 
           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
+          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

@@ -341,7 +341,11 @@ module Ruby2JS
 
         elsif method == :last
           if node.children.length == 2
-            process on_send S(:send, target, :[], s(:int, -1))
+            if es2022
+              process S(:send, target, :at, s(:int, -1))
+            else
+              process on_send S(:send, target, :[], s(:int, -1))
+            end
           elsif node.children.length == 3
             process S(:send, target, :slice,
               s(:send, s(:attr, target, :length), :-, node.children[2]),
@@ -358,8 +362,12 @@ module Ruby2JS
           # resolve negative literal indexes
           i = proc do |index|
             if index.type == :int and index.children.first < 0
-              process S(:send, S(:attr, target, :length), :-,
-                s(:int, -index.children.first))
+              if es2022
+                return process S(:send, target, :at, index)
+              else
+                process S(:send, S(:attr, target, :length), :-,
+                  s(:int, -index.children.first))
+              end
             else
               index
             end

data/lib/ruby2js/filter/lit-element.rb

@@ -1,218 +1,2 @@
-require 'ruby2js'
-
-module Ruby2JS
-  module Filter
-    module LitElement
-      include SEXP
-      extend  SEXP
-
-      LITELEMENT_IMPORT = s(:import,
-        [s(:pair, s(:sym, :from), s(:str, "lit-element"))],
-        [s(:const, nil, :LitElement), s(:attr, nil, :css), s(:attr, nil, :html)]) 
-
-      def initialize(node)
-        super
-        @le_props = nil
-      end
-
-      def on_ivar(node)
-        return super unless @le_props&.include?(node.children.first)
-        s(:attr, s(:self), node.children.first.to_s[1..-1])
-      end
-
-      def on_ivasgn(node)
-        return super unless @le_props&.include?(node.children.first)
-        return super unless node.children.length > 1
-        s(:send, s(:self), node.children.first.to_s[1..-1]+'=',
-          process(node.children[1]))
-      end
-
-      def on_op_asgn(node)
-        return super unless node.children.first.type == :ivasgn
-        var = node.children.first.children.first
-        return super unless @le_props&.include?(var)
-        super node.updated(nil, [s(:attr, s(:attr, nil, :this),
-          var.to_s[1..-1]), *node.children[1..-1]])
-      end
-
-      def on_class(node)
-        cname, inheritance, *body = node.children
-        return super unless inheritance == s(:const, nil, :LitElement)
-
-        @le_props = {}
-        le_walk(node)
-
-        prepend_list << LITELEMENT_IMPORT if modules_enabled?
-
-        nodes = body.dup
-        if nodes.length == 1 and nodes.first&.type == :begin
-          nodes = nodes.first.children.dup
-        end
-
-        # insert/update static get properties() {}
-        unless @le_props.empty?
-          values = nodes.find_index {|child| 
-            child.type == :defs and child.children[0..1] == [s(:self), :properties]
-          }
-
-          if values == nil
-            nodes.unshift s(:defp, s(:self), :properties, s(:args), s(:return, 
-              s(:hash, *@le_props.map {|name, type| s(:pair, s(:str, name.to_s[1..-1]), 
-              s(:hash, s(:pair, s(:sym, :type), s(:const, nil, type || :String))))})))
-          elsif nodes[values].children[3].type == :hash
-            le_props = @le_props.map {|name, type| 
-              [s(:sym, name.to_s[1..-1].to_sym), 
-              s(:hash, s(:pair, s(:sym, :type), s(:const, nil, type || :String)))]
-            }.to_h.merge(
-              nodes[values].children[3].children.map {|pair| pair.children}.to_h
-            )
-
-            nodes[values] = nodes[values].updated(nil,
-              [*nodes[values].children[0..2], s(:hash,
-              *le_props.map{|name, value| s(:pair, name, value)})])
-          end
-        end
-
-        # render of a string is converted to a taglit :html
-        render = nodes.find_index {|child| 
-          child&.type == :def and child.children.first == :render
-        }
-        if render and %i[str dstr].include?(nodes[render].children[2]&.type)
-          nodes[render] = nodes[render].updated(:deff,
-            [*nodes[render].children[0..1],
-            s(:autoreturn, html_wrap(nodes[render].children[2]))])
-        end
-
-        # self.styles returning string is converted to a taglit :css
-        styles = nodes.find_index {|child| 
-          child&.type == :defs and child.children[0..1] == [s(:self), :styles]
-        }
-        if styles and %i[str dstr].include?(nodes[styles].children[3]&.type)
-          string = nodes[styles].children[3]
-          string = s(:dstr, string) if string.type == :str
-          children = string.children.dup
-
-          while children.length > 1 and children.last.type == :str and
-            children.last.children.last.strip == ''
-            children.pop
-          end
-
-          if children.last.type == :str
-            children << s(:str, children.pop.children.first.chomp)
-          end
-
-          nodes[styles] = nodes[styles].updated(nil,
-            [*nodes[styles].children[0..2],
-            s(:autoreturn, s(:taglit, s(:sym, :css),
-            s(:dstr, *children)))])
-        end
-
-        # insert super calls into initializer
-        initialize = nodes.find_index {|child| 
-          child&.type == :def and child.children.first == :initialize
-        }
-        if initialize and nodes[initialize].children.length == 3
-          statements = nodes[initialize].children[2..-1]
-
-          if statements.length == 1 and statements.first.type == :begin
-            statements = statements.first.children 
-          end
-
-          unless statements.any? {|statement| %i[super zuper].include?  statement.type}
-            nodes[initialize] = nodes[initialize].updated(nil,
-            [*nodes[initialize].children[0..1],
-            s(:begin, s(:zsuper), *statements)])
-          end
-        end
-
-        props = @le_props.keys.map {|prop| [prop.to_sym, s(:self)]}.to_h
-
-        nodes.unshift s(:defineProps, props)
-
-        nodes.pop unless nodes.last
-
-        node.updated(nil, [*node.children[0..1], s(:begin, *process_all(nodes))])
-      ensure
-        @le_props = nil
-      end
-
-      def html_wrap(node)
-        if node.type == :str and node.children.first.strip.start_with? '<'
-          s(:taglit, s(:sym, :html), s(:dstr, node))
-        elsif node.type == :dstr
-          prefix = ''
-          node.children.each do |child|
-            break unless child.type == :str
-            prefix += child.children.first
-          end
-
-          return node unless prefix.strip.start_with? '<'
-
-          children = node.children.map do |child|
-            if child.type == :str
-              child
-            else
-              html_wrap(child)
-            end
-          end
-
-          while children.length > 1 and children.last.type == :str and
-            children.last.children.last.strip == ''
-            children.pop
-          end
-
-          if children.last.type == :str
-            children << s(:str, children.pop.children.first.chomp)
-          end
-
-          s(:taglit, s(:sym, :html), node.updated(nil, children))
-        elsif node.type == :begin
-          node.updated(nil, node.children.map {|child| html_wrap(child)})
-        elsif node.type == :if
-          node.updated(nil, [node.children.first,
-            *node.children[1..2].map {|child| html_wrap(child)}])
-        elsif node.type == :block and
-          node.children.first.children[1] == :map
-          node.updated(nil, [*node.children[0..1],
-            html_wrap(node.children[2])])
-        else
-          node
-        end
-      end
-
-      # analyze ivar usage
-      def le_walk(node)
-        node.children.each do |child|
-          next unless child.is_a? Parser::AST::Node
-
-          if child.type == :ivar
-            @le_props[child.children.first] ||= nil
-          elsif child.type == :ivasgn || child.type == :op_asgn
-            prop = child.children.first
-            unless prop.is_a? Symbol
-              prop = prop.children.first if prop.type == :ivasgn
-              next unless prop.is_a? Symbol
-            end
-
-            @le_props[prop] = case child.children.last.type
-              when :str, :dstr
-                :String
-              when :array
-                :Array
-              when :int, :float
-                :Number
-              when :true, :false
-                :Boolean
-              else
-                @le_props[prop] || :Object
-            end
-          else
-            le_walk(child)
-          end
-        end
-      end
-    end
-
-    DEFAULTS.push LitElement
-  end
-end
+# for backwards compatibility
+require_relative './lit'