ruby2js 4.0.0 → 4.0.5

data/lib/ruby2js/converter/taglit.rb

@@ -6,8 +6,15 @@ module Ruby2JS
    #   (dstr)
 
     handle :taglit do |tag, *children|
-      put tag.children.first
-      parse_all(*children, join: '')
+      begin
+        # disable autobinding in tag literals
+        save_autobind, @autobind = @autobind, false
+      
+        put tag.children.first
+        parse_all(*children, join: '')
+      ensure
+        @autobind = save_autobind
+      end
     end
   end
 end

data/lib/ruby2js/converter/while.rb

@@ -22,7 +22,7 @@ module Ruby2JS
           end
         end
 
-        put 'while ('; parse condition; puts ') {'; scope block; sput '}'
+        put 'while ('; parse condition; puts ') {'; redoable block; sput '}'
       ensure
         @next_token = next_token
       end

data/lib/ruby2js/converter/whilepost.rb

@@ -11,7 +11,7 @@ module Ruby2JS
       begin
         next_token, @next_token = @next_token, :continue
 
-        puts 'do {'; scope block; sput '} while ('; parse condition; put ')'
+        puts 'do {'; redoable block; sput '} while ('; parse condition; put ')'
       ensure
         @next_token = next_token
       end

data/lib/ruby2js/converter/xstr.rb

@@ -5,9 +5,8 @@ module Ruby2JS
     #   (str 'a'))
 
     handle :xstr do |*children|
-      str = eval capture { parse_all(*children) }
-
       if @binding
+        str = eval capture { parse_all(*children) }
         puts @binding.eval(str).to_s
       else
         raise SecurityError.new('Insecure operation, eval without binding option')

data/lib/ruby2js/filter/camelCase.rb

@@ -11,6 +11,8 @@ module Ruby2JS
 
       ALLOWLIST = %w{
         attr_accessor
+        attr_reader
+        attr_writer
         method_missing
       }
 

data/lib/ruby2js/filter/functions.rb

@@ -1,4 +1,5 @@
 require 'ruby2js'
+
 require 'regexp_parser/scanner'
 
 module Ruby2JS
@@ -7,7 +8,7 @@ module Ruby2JS
       include SEXP
 
       # require explicit opt-in to to class => constructor mapping
-      Filter.exclude :class
+      Filter.exclude :class, :call
 
       VAR_TO_ASSIGN = {
         lvar: :lvasgn,
@@ -23,7 +24,7 @@ module Ruby2JS
 
       def on_send(node)
         target, method, *args = node.children
-        return super if excluded?(method)
+        return super if excluded?(method) and method != :call
 
         if [:max, :min].include? method and args.length == 0
           if target.type == :array
@@ -36,13 +37,10 @@ module Ruby2JS
             return super
           end
 
-        elsif method == :call and target and target.type == :ivar
-          process S(:send, s(:self), "_#{target.children.first.to_s[1..-1]}",
-            *args)
+        elsif method == :call and target and 
+          (%i[ivar cvar].include?(target.type) or not excluded?(:call))
 
-        elsif method == :call and target and target.type == :cvar
-          process S(:send, s(:attr, s(:self), :constructor),
-            "_#{target.children.first.to_s[2..-1]}", *args)
+          S(:call, process(target), nil, *process_all(args))
 
         elsif method == :keys and args.length == 0 and node.is_method?
           process S(:send, s(:const, nil, :Object), :keys, target)
@@ -212,10 +210,10 @@ module Ruby2JS
                 s(:block, s(:send, nil, :proc), s(:args, s(:arg, :s)),
                   s(:send, s(:lvar, :s), :slice, s(:int, 1))))
             else
-              # str.match(/.../g).map(s => s.match(/.../).slice(1))
+              # (str.match(/.../g) || []).map(s => s.match(/.../).slice(1))
               s(:block, s(:send,
-                s(:send, process(target), :match, gpattern), :map),
-                s(:args, s(:arg, :s)),
+                s(:or, s(:send, process(target), :match, gpattern), s(:array)),
+                :map), s(:args, s(:arg, :s)),
                 s(:return, s(:send, s(:send, s(:lvar, :s), :match, arg),
                 :slice, s(:int, 1))))
             end
@@ -510,6 +508,36 @@ module Ruby2JS
         elsif method == :floor and args.length == 0
           process S(:send, s(:const, nil, :Math), :floor, target)
 
+        elsif method == :rand and target == nil
+          if args.length == 0
+            process S(:send!, s(:const, nil, :Math), :random)
+          elsif %i[irange erange].include? args.first.type
+            range = args.first
+            multiplier = s(:send, range.children.last, :-, range.children.first)
+            if range.children.all? {|child| child.type == :int}
+              multiplier = s(:int, range.children.last.children.last - range.children.first.children.last)
+              multiplier = s(:int, multiplier.children.first + 1) if range.type == :irange
+            elsif range.type == :irange
+              if multiplier.children.last.type == :int
+                diff = multiplier.children.last.children.last - 1
+                multiplier = s(:send, *multiplier.children[0..1], s(:int, diff))
+                multiplier = multiplier.children.first if diff == 0
+                multiplier = s(:send, multiplier.children[0], :+, s(:int, -diff)) if diff < 0
+              else
+                multiplier = s(:send, multiplier, :+, s(:int, 1))
+              end
+            end
+            raw = s(:send, s(:send, s(:const, nil, :Math), :random), :*, multiplier)
+            if range.children.first != s(:int, 0)
+              raw = s(:send, raw, :+, range.children.first)
+            end
+            process S(:send, nil, :parseInt, raw)
+          else
+            process S(:send, nil, :parseInt,
+              s(:send, s(:send, s(:const, nil, :Math), :random),
+              :*, args.first))
+          end
+
         elsif method == :sum and args.length == 0
           process S(:send, target, :reduce, s(:block, s(:send, nil, :proc),
             s(:args, s(:arg, :a), s(:arg, :b)),

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

@@ -0,0 +1,202 @@
+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)
+        s(:send, s(:self), node.children.first.to_s[1..-1]+'=',
+          process(node.children[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].children
+
+          if statements.length == 1 and statements.children.first.type == :begin
+            statements = statements.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 Parser::AST::Node === child
+          le_walk(child)
+
+          if child.type == :ivar
+            @le_props[child.children.first] ||= nil
+          elsif child.type == :ivasgn
+            @le_props[child.children.first] = case child.children.last.type
+              when :str, :dstr
+                :String
+              when :array
+                :Array
+              when :int, :float
+                :Number
+              when :true, :false
+                :Boolean
+              else
+                @le_props[child.children.first] || :Object
+            end
+          end
+        end
+      end
+    end
+
+    DEFAULTS.push LitElement
+  end
+end

data/lib/ruby2js/filter/react.rb

@@ -26,8 +26,8 @@ module Ruby2JS
       extend  SEXP
 
       REACT_IMPORTS = {
-        React: s(:import, ['React'], s(:attr, nil, :React)),
-        ReactDOM: s(:import, ['ReactDOM'], s(:attr, nil, :ReactDOM))
+        React: s(:import, ['react'], s(:attr, nil, :React)),
+        ReactDOM: s(:import, ['react-dom'], s(:attr, nil, :ReactDOM))
       }
 
       # the following command can be used to generate ReactAttrs:
@@ -85,7 +85,6 @@ module Ruby2JS
         @react_props = []
         @react_methods = []
         @react_filter_functions = false
-        @react_imports = false
         @jsx = false
         super
       end
@@ -102,15 +101,6 @@ module Ruby2JS
           @react_filter_functions = true
         end
 
-        if \
-          (defined? Ruby2JS::Filter::ESM and
-          filters.include? Ruby2JS::Filter::ESM) or
-          (defined? Ruby2JS::Filter::CJS and
-          filters.include? Ruby2JS::Filter::CJS)
-        then
-          @react_imports = true
-        end
-
         if \
           defined? Ruby2JS::Filter::JSX and
           filters.include? Ruby2JS::Filter::JSX
@@ -133,7 +123,7 @@ module Ruby2JS
           inheritance == s(:const, s(:const, nil, :React), :Component) or
           inheritance == s(:send, s(:const, nil, :React), :Component)
 
-        prepend_list << REACT_IMPORTS[:React] if @react_imports
+        prepend_list << REACT_IMPORTS[:React] if modules_enabled?
 
         # traverse down to actual list of class statements
         if body.length == 1
@@ -222,7 +212,7 @@ module Ruby2JS
               scan_events[node.children]
             end
           end
-          scan_events[body]
+          scan_events[body] unless es2015
 
           # append statics (if any)
           unless statics.empty?
@@ -323,7 +313,7 @@ module Ruby2JS
             elsif mname == :render and not react_wunderbar_free(block, true)
               if \
                  block.length != 1 or not block.last or
-                not [:send, :block].include? block.last.type
+                not %i[send block xstr].include? block.last.type
               then
                 if @jsx
                   while block.length == 1 and block.first.type == :begin
@@ -445,7 +435,7 @@ module Ruby2JS
             node.children.first == s(:const, nil, :React) or
             node.children.first == s(:const, nil, :ReactDOM)
           then
-            if @react_imports
+            if modules_enabled?
               prepend_list << REACT_IMPORTS[node.children.first.children.last]
             end
 

data/lib/ruby2js/filter/require.rb

@@ -111,6 +111,7 @@ module Ruby2JS
 
               importname = Pathname.new(filename).relative_path_from(Pathname.new(dirname)).to_s
               importname = Pathname.new(@require_relative).join(importname).to_s
+              importname = "./#{importname}" unless importname.start_with? '.'
 
               prepend_list << s(:import, importname, *imports)
 
@@ -152,12 +153,7 @@ module Ruby2JS
             end
           end
         else
-          begin
-            require_expr, @require_expr = @require_expr, true
-            super
-          ensure
-            @require_expr = require_expr
-          end
+          super
         end
       end
 

data/lib/ruby2js/filter/stimulus.rb

@@ -51,8 +51,10 @@ module Ruby2JS
         @stim_classes = Set.new
         stim_walk(node)
 
-        prepend_list << (@options[:import_from_skypack] ?
-          STIMULUS_IMPORT_SKYPACK : STIMULUS_IMPORT)
+        if modules_enabled?
+          prepend_list << (@options[:import_from_skypack] ?
+            STIMULUS_IMPORT_SKYPACK : STIMULUS_IMPORT)
+        end
 
         nodes = body
         if nodes.length == 1 and nodes.first&.type == :begin