ruby2js 3.5.1 → 4.0.0

data/lib/ruby2js/filter/return.rb

@@ -20,7 +20,9 @@ module Ruby2JS
 
       def on_def(node)
         node = super
-        return node unless node.type == :def
+        return node unless node.type == :def or node.type == :deff
+        return node if [:constructor, :initialize].include?(node.children.first)
+
         children = node.children[1..-1]
 
         children[-1] = s(:nil) if children.last == nil
@@ -28,6 +30,18 @@ module Ruby2JS
         node.updated nil, [node.children[0], children.first,
           s(:autoreturn, *children[1..-1])]
       end
+
+      def on_deff(node)
+        on_def(node)
+      end
+
+      def on_defs(node)
+        node = super
+        return node unless node.type == :defs
+        children = node.children[3..-1]
+        children[-1] = s(:nil) if children.last == nil
+        node.updated nil, [*node.children[0..2], s(:autoreturn, *children)]
+      end
     end
 
     DEFAULTS.push Return

data/lib/ruby2js/filter/securerandom.rb

@@ -0,0 +1,33 @@
+require 'ruby2js'
+require 'set'
+
+# Experimental secure random support
+
+module Ruby2JS
+  module Filter
+    module SecureRandom
+      include SEXP
+      extend SEXP
+
+      IMPORT_BASE62_RANDOM = s(:import, ['base62-random'],
+        s(:attr, nil, :base62_random))
+
+      def on_send(node)
+        target, method, *args = node.children
+
+        if target == s(:const, nil, :SecureRandom)
+          if method == :alphanumeric and args.length == 1
+            prepend_list << IMPORT_BASE62_RANDOM
+            node.updated(nil, [nil, :base62_random, *args])
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+    end
+
+    DEFAULTS.push SecureRandom
+  end
+end

data/lib/ruby2js/filter/stimulus.rb

@@ -0,0 +1,185 @@
+#
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module Stimulus
+      include SEXP
+      extend  SEXP
+
+      STIMULUS_IMPORT = s(:import,
+        [s(:pair, s(:sym, :as), s(:const, nil, :Stimulus)),
+          s(:pair, s(:sym, :from), s(:str, "stimulus"))],
+          s(:str, '*'))
+
+      STIMULUS_IMPORT_SKYPACK = s(:import,
+        [s(:pair, s(:sym, :as), s(:const, nil, :Stimulus)),
+          s(:pair, s(:sym, :from), s(:str, "https://cdn.skypack.dev/stimulus"))],
+          s(:str, '*'))
+
+      def initialize(*args)
+        super
+        @stim_scope = []
+        @stim_subclasses = []
+      end
+
+      def on_module(node)
+        save_scope = @stim_scope
+        @stim_scope += @namespace.resolve(node.children.first)
+        super
+      ensure
+        @stim_scope = save_scope
+      end
+
+      def on_class(node)
+        cname, inheritance, *body = node.children
+        return super unless inheritance == s(:const, nil, :Stimulus) or
+          inheritance == s(:const, s(:const, nil, :Stimulus), :Controller) or
+          inheritance == s(:send, s(:const, nil, :Stimulus), :Controller) or
+          @stim_subclasses.include? @namespace.resolve(inheritance)
+
+        if inheritance == s(:const, nil, :Stimulus)
+          node = node.updated(nil, [node.children.first,
+            s(:const, s(:const, nil, :Stimulus), :Controller),
+            *node.children[2..-1]])
+        end
+
+        @stim_subclasses << @stim_scope + @namespace.resolve(cname)
+
+        @stim_targets = Set.new
+        @stim_values = Set.new
+        @stim_classes = Set.new
+        stim_walk(node)
+
+        prepend_list << (@options[:import_from_skypack] ?
+          STIMULUS_IMPORT_SKYPACK : STIMULUS_IMPORT)
+
+        nodes = body
+        if nodes.length == 1 and nodes.first&.type == :begin
+          nodes = nodes.first.children.dup
+        end
+
+        unless @stim_classes.empty?
+          classes = nodes.find_index {|child| 
+            child.type == :send and child.children[0..1] == [s(:self), :classes=]
+          }
+
+          if classes == nil
+            nodes.unshift s(:send, s(:self), :classes=, s(:array, *@stim_classes))
+          elsif nodes[classes].children[2].type == :array
+            @stim_classes.merge(nodes[classes].children[2].children)
+            nodes[classes] = nodes[classes].updated(nil,
+              [*nodes[classes].children[0..1], s(:array, *@stim_classes)])
+          end
+        end
+
+        unless @stim_values.empty?
+          values = nodes.find_index {|child| 
+            child.type == :send and child.children[0..1] == [s(:self), :values=]
+          }
+
+          if values == nil
+            nodes.unshift s(:send, s(:self), :values=, s(:hash,
+            *@stim_values.map {|name| s(:pair, name, s(:const, nil, :String))}))
+          elsif nodes[values].children[2].type == :hash
+            stim_values = @stim_values.map {|name| 
+              [s(:sym, name.children.first.to_sym), s(:const, nil, :String)]
+            }.to_h.merge(
+              nodes[values].children[2].children.map {|pair| pair.children}.to_h
+            )
+
+            nodes[values] = nodes[values].updated(nil,
+              [*nodes[values].children[0..1], s(:hash,
+              *stim_values.map{|name, value| s(:pair, name, value)})])
+          end
+        end
+
+        unless @stim_targets.empty?
+          targets = nodes.find_index {|child| 
+            child.type == :send and child.children[0..1] == [s(:self), :targets=]
+          }
+
+          if targets == nil
+            nodes.unshift s(:send, s(:self), :targets=, s(:array, *@stim_targets))
+          elsif nodes[targets].children[2].type == :array
+            @stim_targets.merge(nodes[targets].children[2].children)
+            nodes[targets] = nodes[targets].updated(nil,
+              [*nodes[targets].children[0..1], s(:array, *@stim_targets)])
+          end
+        end
+
+        props = [:element, :application]
+
+        props += @stim_targets.map do |name|
+          name = name.children.first
+          ["#{name}Target", "#{name}Targets", "has#{name[0].upcase}#{name[1..-1]}Target"]
+        end
+
+        props += @stim_values.map do |name|
+          name = name.children.first
+          ["#{name}Value", "has#{name[0].upcase}#{name[1..-1]}Value"]
+        end
+
+        props += @stim_classes.map do |name|
+          name = name.children.first
+          ["#{name}Class", "has#{name[0].upcase}#{name[1..-1]}Class"]
+        end
+
+        props = props.flatten.map {|prop| [prop.to_sym, s(:self)]}.to_h
+
+        props[:initialize] = s(:autobind, s(:self))
+
+        nodes.unshift s(:defineProps, props)
+
+        nodes.pop unless nodes.last
+
+        node.updated(nil, [*node.children[0..1], s(:begin, *process_all(nodes))])
+      end
+
+      # analyze ivar usage
+      def stim_walk(node)
+        node.children.each do |child|
+          next unless Parser::AST::Node === child
+          stim_walk(child)
+
+          if child.type == :send and child.children.length == 2 and
+            [nil, s(:self), s(:send, nil, :this)].include? child.children[0]
+
+            if child.children[1] =~ /^has([A-Z]\w*)(Target|Value|Class)$/
+              name = s(:str, $1[0].downcase + $1[1..-1])
+              @stim_targets.add name if $2 == 'Target'
+              @stim_values.add name if $2 == 'Value'
+              @stim_classes.add name if $2 == 'Class'
+            elsif child.children[1] =~ /^(\w+)Targets?$/
+              @stim_targets.add s(:str, $1)
+            elsif child.children[1] =~ /^(\w+)Value=?$/
+              @stim_values.add s(:str, $1)
+            elsif child.children[1] =~ /^(\w+)Class$/
+              @stim_classes.add s(:str, $1)
+            end
+
+          elsif child.type == :send and child.children.length == 3 and
+            [s(:self), s(:send, nil, :this)].include? child.children[0]
+
+            if child.children[1] =~ /^(\w+)Value=$/
+              @stim_values.add s(:str, $1)
+            end
+
+          elsif child.type == :lvasgn
+            if child.children[0] =~ /^(\w+)Value$/
+              @stim_values.add s(:str, $1)
+            end
+
+          elsif child.type == :def
+            if child.children[0] =~ /^(\w+)ValueChanged$/
+              @stim_values.add s(:str, $1)
+            end
+          end
+
+        end
+      end
+    end
+
+    DEFAULTS.push Stimulus
+  end
+end

data/lib/ruby2js/filter/vue.rb

@@ -106,6 +106,7 @@ module Ruby2JS
         computed = []
         setters = []
         options = []
+        watch = nil
         el = nil
         mixins = []
 
@@ -205,6 +206,9 @@ module Ruby2JS
                 end
 
                 @vue_h = args.children.first.children.last
+              elsif method == :watch and args.children.length == 0 and block.type == :hash
+                watch = process(block)
+                next
               elsif method == :initialize
                 method = :data
 
@@ -332,6 +336,11 @@ module Ruby2JS
           hash << s(:pair, s(:sym, :computed), s(:hash, *computed))
         end
 
+        # append watch to hash
+        if watch
+          hash << s(:pair, s(:sym, :watch), watch)
+        end
+
         # convert class name to camel case
         cname = cname.children.last
         camel = cname.to_s.gsub(/[^\w]/, '-').

data/lib/ruby2js/jsx.rb

@@ -0,0 +1,291 @@
+# convert a JSX expression into wunderbar statements
+#
+# Once the syntax is converted to pure Ruby statements,
+# it can then be converted into either React or Vue
+# rendering instructions.
+
+module Ruby2JS
+  def self.jsx2_rb(string)
+    JsxParser.new(string.chars.each).parse.join("\n")
+  end
+
+  class JsxParser
+    def initialize(stream)
+      @stream = stream
+      @state = :text
+      @text = ''
+      @result = []
+      @element = ''
+      @attrs = {}
+      @attr_name = ''
+      @value = ''
+      @tag_stack = []
+      @expr_nesting = 0
+      @wrap_value = true
+    end
+
+    def parse(state = :text, wrap_value = true)
+      @wrap_value = wrap_value
+      @state = state
+      backtrace = ''
+      prev = nil
+
+      loop do
+        c = @stream.next
+
+        if c == "\n"
+          backtrace = ''
+        else
+          backtrace += c
+        end
+
+        case @state
+        when :text
+          if c == '<'
+            @result << "_(\"#{@text.strip}\")" unless @text.strip.empty?
+            if @tag_stack.empty?
+              @result += self.class.new(@stream).parse(:element)
+              @state = :text
+              @text = ''
+            else
+              @state = :element
+              @element = ''
+              @attrs = {}
+            end
+          elsif c == '\\'
+            @text += c + c
+          elsif c == '{'
+            @result << "_(\"#{@text}\")" unless @text.empty?
+            @result += parse_expr
+            @text = ''
+          else
+            @text += c unless @text.empty? and c =~ /\s/
+          end
+
+        when :element
+          if c == '/'
+            if @element == ''
+              @state = :close
+              @element = ''
+            else
+              @state = :void
+            end
+          elsif c == '>'
+            @result << "_#{@element} do"
+            @tag_stack << @element
+            @state = :text
+            @text = ''
+          elsif c == ' '
+            @state = :attr_name
+            @attr_name = ''
+            @attrs = {}
+          elsif c == '-'
+            @element += '_'
+          elsif c =~ /^\w$/
+            @element += c
+          else
+            raise SyntaxError.new("invalid character in element name: #{c.inspect}")
+          end
+
+        when :close
+          if c == '>'
+            if @element == @tag_stack.last
+              @tag_stack.pop
+            elsif @tag_stack.last
+              raise SyntaxError.new("missing close tag for: #{@tag_stack.last.inspect}")
+            else
+              raise SyntaxError.new("close tag for element that is not open: #{@element}")
+            end
+
+            @result << 'end'
+            return @result if @tag_stack.empty?
+          elsif c =~ /^\w$/
+            @element += c
+          elsif c != ' '
+            raise SyntaxError.new("invalid character in element: #{c.inspect}")
+          end
+
+        when :void
+          if c == '>'
+            if @attrs.empty?
+              @result << "_#{@element}"
+            else
+              @result << "_#{@element}(#{@attrs.map {|name, value| "#{name}: #{value}"}.join(' ')})"
+            end
+            return @result if @tag_stack.empty?
+
+            @state = :text
+            @text = ''
+          elsif c != ' '
+            raise SyntaxError.new('invalid character in element: "/"')
+          end
+
+        when :attr_name
+          if c =~ /^\w$/
+            @attr_name += c
+          elsif c == '='
+            @state = :attr_value
+            @value = ''
+          elsif c == '/' and @attr_name == ''
+            @state = :void
+          elsif c == ' ' or c == "\n" or c == '>'
+            if not @attr_name.empty?
+              raise SyntaxError.new("missing \"=\" after attribute #{@attr_name.inspect} " +
+                "in element #{@element.inspect}")
+            elsif c == '>'
+              @result << "_#{@element}(#{@attrs.map {|name, value| "#{name}: #{value}"}.join(' ')}) do"
+              @tag_stack << @element
+              @state = :text
+              @text = ''
+            end
+          else
+            raise SyntaxError.new("invalid character in attribute name: #{c.inspect}")
+          end
+
+        when :attr_value
+          if c == '"'
+            @state = :dquote
+          elsif c == "'"
+            @state = :squote
+          elsif c == '{'
+            @attrs[@attr_name] = parse_value
+            @state = :attr_name
+            @attr_name = ''
+          else
+            raise SyntaxError.new("invalid value for attribute #{@attr_name.inspect} " +
+              "in element #{@element.inspect}")
+          end
+
+        when :dquote
+          if c == '"'
+            @attrs[@attr_name] = '"' + @value + '"'
+            @state = :attr_name
+            @attr_name = ''
+          elsif c == "\\"
+            @value += c + c
+          else
+            @value += c
+          end
+
+        when :squote
+          if c == "'"
+            @attrs[@attr_name] = "'" + @value + "'"
+            @state = :attr_name
+            @attr_name = ''
+          elsif c == "\\"
+            @value += c + c
+          else
+            @value += c
+          end
+
+        when :expr
+          if c == "}"
+            if @expr_nesting > 0
+              @value += c
+              @expr_nesting -= 1
+            else
+              @result << (@wrap_value ? "_(#{@value})" : @value)
+              return @result
+            end
+          elsif c == '<'
+            if prev =~ /[\w\)\]\}]/
+              @value += c # less than
+            elsif prev == ' '
+              if @stream.peek =~ /[a-zA-Z]/
+                @value += parse_element.join(';')
+                @wrap_value = false
+              else
+                @value += c
+              end
+            else
+              @value += parse_element.join(';')
+              @wrap_value = false
+            end
+          else
+            @value += c
+            @state = :expr_squote if c == "'"
+            @state = :expr_dquote if c == '"'
+            @expr_nesting += 1 if c == '{'
+          end
+
+        when :expr_squote
+          @value += c
+          if c == "\\"
+            @state = :expr_squote_backslash
+          elsif c == "'"
+            @state = :expr
+          end
+
+        when :expr_squote_backslash
+          @value += c
+          @state = :expr_squote
+
+        when :expr_dquote
+          @value += c
+          if c == "\\"
+            @state = :expr_dquote_backslash
+          elsif c == '#'
+            @state = :expr_dquote_hash
+          elsif c == '"'
+            @state = :expr
+          end
+
+        when :expr_dquote_backslash
+          @value += c
+          @state = :expr_dquote
+
+        when :expr_dquote_hash
+          @value += c
+          @value += parse_value + '}' if c == '{'
+          @state = :expr_dquote
+
+        else
+          raise RangeError.new("internal state error in JSX: #{@state.inspect}")
+        end
+
+        prev = c
+      end
+
+      unless @tag_stack.empty?
+        raise SyntaxError.new("missing close tag for: #{@tag_stack.last.inspect}")
+      end
+
+      case @state
+      when :text
+        @result << "_(\"#{@text.strip}\")" unless @text.strip.empty?
+
+      when :element, :attr_name, :attr_value
+        raise SyntaxError.new("unclosed element #{@element.inspect}")
+
+      when :dquote, :squote, :expr_dquote, :expr_dquote_backslash, 
+        :expr_squote, :expr_squote_backslash
+        raise SyntaxError.new("unclosed quote")
+
+      when :expr
+        raise SyntaxError.new("unclosed value")
+
+      else
+        raise RangeError.new("internal state error in JSX: #{@state.inspect}")
+      end
+
+      @result
+    rescue SyntaxError => e
+      e.set_backtrace backtrace
+      raise e
+    end
+
+    private
+
+    def parse_value
+      self.class.new(@stream).parse(:expr, false).join(',')
+    end
+
+    def parse_expr
+      self.class.new(@stream).parse(:expr, true)
+    end
+
+    def parse_element
+      self.class.new(@stream).parse(:element)
+    end
+  end
+end