ruby2js 3.5.3 → 4.0.2

data/lib/ruby2js/filter/require.rb

@@ -1,4 +1,5 @@
 require 'ruby2js'
+require 'pathname'
 
 module Ruby2JS
   module Filter
@@ -13,9 +14,17 @@ module Ruby2JS
 
       def initialize(*args)
         @require_expr = nil
+        @require_seen = {}
+        @require_relative = '.'
         super
       end
 
+      def options=(options)
+        super
+        @require_autoexports = !@disable_autoexports && options[:autoexports]
+        @require_recursive = options[:require_recursive]
+      end
+
       def on_send(node)
         if \
           not @require_expr and # only statements
@@ -44,11 +53,98 @@ module Ruby2JS
               filename += '.js.rb'
             end
 
-            @options[:file2] = filename
-            ast, comments = Ruby2JS.parse(File.read(filename), filename)
-            @comments.merge! Parser::Source::Comment.associate(ast, comments)
-            @comments[node] += @comments[ast]
-            process ast
+            realpath = File.realpath(filename)
+            if @require_seen[realpath]
+              ast = s(:hide)
+            else
+              @require_seen[realpath] = []
+
+              @options[:file2] = filename
+              ast, comments = Ruby2JS.parse(File.read(filename), filename)
+              @comments.merge! Parser::Source::Comment.associate(ast, comments)
+              @comments[node] += @comments[ast]
+            end
+
+            children = ast.type == :begin ? ast.children : [ast]
+
+            named_exports = []
+            auto_exports = []
+            default_exports = []
+            children.each do |child|
+              if child&.type == :send and child.children[0..1] == [nil, :export]
+                child = child.children[2]
+                if child&.type == :send and child.children[0..1] == [nil, :default]
+                  child = child.children[2]
+                  target = default_exports
+                else
+                  target = named_exports
+                end
+              elsif @require_autoexports
+                target = auto_exports
+              else
+                next
+              end
+
+              if %i[class module].include? child.type and child.children[0].children[0] == nil
+                target << child.children[0].children[1]
+              elsif child.type == :casgn and child.children[0] == nil
+                target << child.children[1]
+              elsif child.type == :def
+                target << child.children[0]
+              end
+            end
+
+            if @require_autoexports == :default and auto_exports.length == 1
+              default_exports += auto_exports
+            else
+              named_exports += auto_exports
+            end
+
+            imports = @require_seen[realpath]
+            imports << s(:const, nil, default_exports.first) unless default_exports.empty?
+            imports << named_exports.map {|id| s(:const, nil, id)} unless named_exports.empty?
+
+            if imports.empty?
+              process ast
+            else
+              @require_seen[realpath] = imports
+
+              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)
+
+              save_prepend_list = prepend_list.dup
+
+              begin
+                require_relative = @require_relative
+                @require_relative = Pathname.new(@require_relative).join(basename).parent.to_s
+                node = process s(:hide, ast)
+              ensure
+                @require_relative = require_relative
+              end
+
+              if @require_recursive
+                block = node.children
+                while block.length == 1 and block.first.type == :begin
+                   block = block.first.children
+                end
+
+                block.each do |child|
+                  if child&.type == :import
+                    puts ['rr', basename, child.inspect]
+                    prepend_list << child 
+                  end
+                end
+              else
+                prepend_list.keep_if do |import|
+                  save_prepend_list.include? import 
+                end
+              end
+
+              node
+            end
           ensure
             if file2
               @options[:file2] = file2
@@ -57,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/return.rb

@@ -20,7 +20,7 @@ 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]
@@ -30,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/stimulus.rb

@@ -0,0 +1,187 @@
+#
+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)
+
+        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
+          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/jsx.rb

@@ -0,0 +1,309 @@
+# 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.respond_to?(:next) ? stream : OpalEnumerator.new(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
+
+  # Opal's enumerator doesn't currently support next and peek methods.
+  # Build a wrapper that adds those methods.
+  class OpalEnumerator
+    def initialize(stream)
+      @stream = stream.to_a
+    end
+
+    def next
+      raise StopIteration.new if @stream.empty?
+      @stream.shift
+    end
+
+    def peek
+      raise StopIteration.new if @stream.empty?
+      @stream.first
+    end
+  end
+end