ruby2js 4.1.7 → 4.2.0

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/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/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)
-        _, 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'

data/lib/ruby2js/filter/lit.rb

@@ -0,0 +1,290 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module Lit
+      include SEXP
+      extend  SEXP
+
+      LITELEMENT_IMPORT = s(:import,
+        [s(:pair, s(:sym, :from), s(:str, "lit"))],
+        [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)
+        process 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
+
+        process 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)
+        class_name, 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]) or
+            (child.type == :send and child.children[0..1] == [s(:self), :properties=])
+          }
+
+          if values == nil
+            if es2022
+              nodes.unshift process(s(:casgn, nil, :properties, 
+                s(:hash, *@le_props.map {|name, type| s(:pair, s(:sym, name.to_s[1..-1]), 
+                s(:hash, s(:pair, s(:sym, :type), s(:const, nil, type || :String))))})))
+            else
+              nodes.unshift process(s(:defp, s(:self), :properties, s(:args), s(:return, 
+                s(:hash, *@le_props.map {|name, type| s(:pair, s(:sym, name.to_s[1..-1]), 
+                s(:hash, s(:pair, s(:sym, :type), s(:const, nil, type || :String))))}))))
+            end
+          elsif nodes[values].children.last.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.last.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
+
+        # customElement is converted to customElements.define
+        customElement = nodes.find_index {|child| 
+          child&.type == :send and (child.children[0..1] == [nil, :customElement] || child.children[0..1] == [nil, :custom_element])
+        }
+        if customElement and nodes[customElement].children.length == 3
+          nodes[customElement] = nodes[customElement].updated(nil,
+            [s(:attr, nil, :customElements), :define,
+            nodes[customElement].children.last, class_name])
+        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 begin if block].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 == :ivasgn and child.children[0] == :@styles) or
+          (child&.type == :defs and child.children[0..1] == [s(:self), :styles]) or
+          (child&.type == :send and child.children[0..1] == [s(:self), :styles=])
+        }
+        if styles and %i[str dstr].include?(nodes[styles].children.last&.type)
+          string = nodes[styles].children.last
+          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
+
+          if es2022
+            nodes[styles] = nodes[styles].updated(:casgn,
+              [nil, :styles, s(:taglit, s(:sym, :css),
+              s(:dstr, *children))])
+          else
+            nodes[styles] = nodes[styles].updated(:defp,
+              [s(:self), :styles, s(:args),
+              s(:autoreturn, s(:taglit, s(:sym, :css),
+              s(:dstr, *children)))])
+          end
+        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/methods inherited from LitElement
+        props = {
+          hasUpdated: s(:self),
+          performUpdate: s(:autobind, s(:self)),
+          renderRoot: s(:self),
+          requestUpdate: s(:autobind, s(:self)),
+          shadowRoot: s(:self),
+          updateComplete: s(:self),
+        }
+
+        # local props
+        props.merge! @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)
+        return node unless node.is_a?(Parser::AST::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
+
+      def on_def(node)
+        node = super
+        return node if [:constructor, :initialize].include?(node.children.first)
+
+        children = node.children[1..-1]
+
+        node.updated nil, [node.children[0], children.first,
+          *(children[1..-1].map {|child| html_wrap(child) })]
+      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
+            next if child.children.first.to_s.start_with?("@_")
+
+            @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
+
+            next if prop.to_s.start_with?("@_")
+
+            @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
+
+      def on_send(node)
+        target, method, *args = node.children
+
+        return super if target
+        return super unless %i{query queryAll queryAsync}.include? method
+        return super unless args.length == 1
+
+        result = s(:csend, s(:attr, s(:self), :renderRoot),
+          (method == :query ? 'querySelector' : 'querySelectorAll'),
+          args.first)
+
+        if method == :queryAsync
+          result = s(:block, s(:send, s(:attr, s(:self), :updateComplete),
+            :then), s(:args), result)
+        end
+
+        result
+      end
+    end
+
+    DEFAULTS.push Lit
+  end
+end

data/lib/ruby2js/filter/react.rb

@@ -41,9 +41,16 @@ module Ruby2JS
       #
       def self.genAttrs
         unless RUBY_ENGINE == 'opal'
-          require 'nokogumbo'
-          page = 'https://facebook.github.io/react/docs/tags-and-attributes.html'
-          doc = Nokogiri::HTML5.get(page)
+          require 'nokogiri'
+          require 'uri'
+          require 'net/http'
+
+          page = 'https://reactjs.org/docs/dom-elements.html'
+          uri = URI.parse(page)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          data = http.get(uri.request_uri).body
+          doc = Nokogiri::HTML5::Document.parse(data)
 
           # delete contents of page prior to the list of supported attributes
           attrs = doc.at('a[name=supported-attributes]')
@@ -51,7 +58,7 @@ module Ruby2JS
           attrs.previous_sibling.remove while attrs and attrs.previous_sibling
 
           # extract attribute names with uppercase chars from code and format
-          attrs = doc.search('code').map(&:text).join(' ')
+          attrs = doc.search('div[data-language=text] pre code').map(&:text).join(' ')
           attrs = attrs.split(/\s+/).grep(/[A-Z]/).sort.uniq.join(' ')
           puts "ReactAttrs = %w(#{attrs})".gsub(/(.{1,72})(\s+|\Z)/, "\\1\n")
         end

data/lib/ruby2js/version.rb

@@ -1,8 +1,8 @@
 module Ruby2JS
   module VERSION #:nodoc:
     MAJOR = 4
-    MINOR = 1
-    TINY  = 7
+    MINOR = 2
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/tasks/install/{litelement.rb → lit-webpacker.rb}

@@ -1,5 +1,5 @@
-@ruby2js_options = {filters: ['lit-element']}
-@yarn_add='lit-element'
+@ruby2js_options = {filters: ['lit']}
+@yarn_add='lit'
 eval IO.read "#{__dir__}/webpacker.rb"
 
 directory File.expand_path("app/javascript/elements", __dir__),

data/lib/tasks/install/stimulus-rollup.rb

@@ -15,7 +15,8 @@ insert_into_file Rails.root.join("rollup.config.js").to_s,
     })
   CONFIG
 
-# monkey patch stimulus:manifest:update to find .rb.js controllers too
+# monkey patch stimulus:manifest:update to find .rb.js controllers too.
+# See https://github.com/hotwired/stimulus-rails/issues/76
 append_to_file Rails.root.join('config/application.rb').to_s,
   "\n" + <<~'CONFIG'
     require 'stimulus/manifest'