ruby2js 4.1.5 → 4.2.1

data/lib/ruby2js/converter/block.rb

@@ -69,5 +69,19 @@ module Ruby2JS
         parse s(@ast.children[0].type, *call.children, function), @state
       end
     end
+
+    # (numblock
+    #   (send nil :x)
+    #   1
+    #   (lvar :_1))
+
+    handle :numblock do |call, count, block|
+      parse s(:block,
+        call,
+        s(:args, *((1..count).map {|i| s(:arg, "_#{i}")})),
+        block
+      )
+    end
+
   end
 end

data/lib/ruby2js/converter/logical.rb

@@ -73,12 +73,12 @@ module Ruby2JS
         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/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

@@ -162,6 +162,9 @@ module Ruby2JS
         elsif method == :to_f
           process node.updated :send, [nil, :parseFloat, target, *args]
 
+        elsif method == :to_json
+          process node.updated :send, [s(:const, nil, :JSON), :stringify, target, *args]
+
         elsif method == :sub and args.length == 2
           if args[1].type == :str
             args[1] = s(:str, args[1].children.first.gsub(/\\(\d)/, "$\\1"))
@@ -503,6 +506,12 @@ module Ruby2JS
               s(:regexp, s(:str, '\A\s+') , s(:regopt)), s(:str, '')])
           end
 
+        elsif method == :index
+          process node.updated(nil, [target, :indexOf, *args])
+
+        elsif method == :rindex
+          process node.updated(nil, [target, :lastIndexOf, *args])
+
         elsif method == :class and args.length==0 and not node.is_method?
           process node.updated(:attr, [target, :constructor])
 
@@ -515,6 +524,9 @@ module Ruby2JS
         elsif method == :abs and args.length == 0
           process S(:send, s(:const, nil, :Math), :abs, target)
 
+        elsif method == :round and args.length == 0
+          process S(:send, s(:const, nil, :Math), :round, target)
+
         elsif method == :ceil and args.length == 0
           process S(:send, s(:const, nil, :Math), :ceil, target)
 
@@ -570,6 +582,13 @@ module Ruby2JS
           process S(:send, s(:attr, target, :prototype), :[]=, args[0],
             s(:attr, s(:attr, target, :prototype), args[1].children[0]))
 
+        elsif method == :new and args.length == 2 and target == s(:const, nil, :Array)
+          if es2015
+            s(:send, S(:send, target, :new, args.first), :fill, args.last)
+          else
+            super
+          end
+
         else
           super
         end
@@ -616,6 +635,11 @@ module Ruby2JS
           node.updated nil, [process(call), process(node.children[1]),
             s(:autoreturn, *process_all(node.children[2..-1]))]
 
+        elsif method == :index and call.children.length == 2
+            call = call.updated nil, [call.children.first, :findIndex]
+            node.updated nil, [process(call), process(node.children[1]),
+              s(:autoreturn, *process_all(node.children[2..-1]))]
+
         elsif method == :map and call.children.length == 2
           node.updated nil, [process(call), process(node.children[1]),
             s(:autoreturn, *process_all(node.children[2..-1]))]

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'