prettyrb 0.1.0 → 0.5.0

data/lib/prettyrb/formatter.rb

@@ -0,0 +1,33 @@
+module Prettyrb
+  MAX_LINE_LENGTH = 100
+
+  class Formatter
+    def initialize(code)
+      @code = code
+    end
+
+    def format
+      parser = Parser::CurrentRuby.new(Prettyrb::Builder.new)
+
+      parser.diagnostics.all_errors_are_fatal = true
+      parser.diagnostics.ignore_warnings      = true
+
+      parser.diagnostics.consumer = lambda do |diagnostic|
+        $stderr.puts(diagnostic.render)
+      end
+
+      root_node, _comments = parser.parse_with_comments(
+        Parser::CurrentRuby.send(:setup_source_buffer, "file='(string)'", 1, @code, parser.default_encoding)
+      )
+
+      visitor = Visitor.new(root_node)
+      visitor.visit(root_node)
+
+      visitor.output
+    end
+
+    private
+
+    attr_reader :code
+  end
+end

data/lib/prettyrb/nodes/and_node.rb

@@ -0,0 +1,11 @@
+module Prettyrb
+  module Nodes
+    class AndNode < BaseNode
+      include LogicalOperatorHelper
+
+      def operator
+        "&&"
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/base_node.rb

@@ -0,0 +1,34 @@
+require "delegate"
+
+module Prettyrb
+  module Nodes
+    class BaseNode < Parser::AST::Node
+      def initialize(type, children, properties)
+        @mutable = {}
+
+        super
+
+        children&.each do |child|
+          next unless child.is_a?(BaseNode)
+          child.parent = self
+        end
+
+        self
+      end
+
+      def parent
+        @mutable[:parent]
+      end
+
+      def string?
+        type == :str || type == :dstr
+      end
+
+      protected
+
+      def parent=(parent)
+        @mutable[:parent] = parent
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/def_node.rb

@@ -0,0 +1,17 @@
+module Prettyrb
+  module Nodes
+    class DefNode < BaseNode
+      def name
+        children[0]
+      end
+
+      def args
+        children[1]
+      end
+
+      def body
+        children[2]
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/dstr_node.rb

@@ -0,0 +1,20 @@
+module Prettyrb
+  module Nodes
+    class DstrNode < BaseNode
+      include StringHelper
+
+      HEREDOC_TYPE_REGEX = /<<(.)?/
+
+      def format
+        raw_content = loc.expression.source
+        content = raw_content[1...-1]
+
+        if raw_content[0] == "'"
+          content.gsub('"', '\\"').gsub('#{', '\\#{')
+        else
+          content.gsub("\\", "\\\\")
+        end
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/if_node.rb

@@ -0,0 +1,63 @@
+module Prettyrb
+  module Nodes
+    class IfNode < BaseNode
+      def if_type
+        if is_elsif?
+          "elsif"
+        elsif unless_node?
+          "unless"
+        else
+          "if"
+        end
+      end
+
+      def conditions
+        children[0]
+      end
+
+      def body_node
+        if unless_node?
+          children[2]
+        else
+          children[1]
+        end
+      end
+
+      def else_body_node
+        if unless_node?
+          children[1]
+        else
+          children[2]
+        end
+      end
+
+      def has_elsif?
+        else_body_node&.type == :if && children[1]&.type != :if
+      end
+
+      def is_elsif?
+        parent&.type == :if && parent&.children[1]&.type != :if
+      end
+
+      def unless_node?
+        children[1].nil? && children[2] != :if
+      end
+
+      def elsif_branches
+        if has_elsif?
+          [else_body_node] + else_body_node.elsif_branches
+        else
+          []
+        end
+      end
+
+      def else_branch
+        if has_elsif?
+          elsif_branches.last.children[2]
+        else
+          else_body_node
+        end
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/logical_operator_helper.rb

@@ -0,0 +1,13 @@
+module Prettyrb
+  module Nodes
+    module LogicalOperatorHelper
+      def left
+        children[0]
+      end
+
+      def right
+        children[1]
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/or_node.rb

@@ -0,0 +1,11 @@
+module Prettyrb
+  module Nodes
+    class OrNode < BaseNode
+      include LogicalOperatorHelper
+
+      def operator
+        "||"
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/regexp_node.rb

@@ -0,0 +1,41 @@
+module Prettyrb
+  module Nodes
+    class RegexpNode < BaseNode
+      include StringHelper
+
+      PERCENT_PAIRS = {
+        "{" => "}",
+        "[" => "]",
+        "(" => ")",
+        "<" => ">",
+      }
+
+      def percent?
+        loc.expression.source.start_with?("%")
+      end
+
+      def percent_type
+        loc.expression.source[1]
+      end
+
+      def start_delimiter
+        loc.expression.source[2]
+      end
+
+      def end_delimiter
+        PERCENT_PAIRS.fetch(start_delimiter, start_delimiter)
+      end
+
+      def format
+        raw_content = loc.expression.source
+        content = raw_content[1...-1]
+
+        if raw_content[0] == "'"
+          content.gsub('"', '\\"').gsub('#{', '\\#{')
+        else
+          content.gsub("\\", "\\\\")
+        end
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/send_node.rb

@@ -0,0 +1,63 @@
+module Prettyrb
+  module Nodes
+    class SendNode < BaseNode
+      def target
+        children[0]
+      end
+
+      def method
+        children[1]
+      end
+
+      def arguments
+        children[2..-1]
+      end
+
+      def self_target?
+        children[2].nil? && method.to_s.end_with?("@")
+      end
+
+      def infix?
+        !children[1].to_s.match?(/^[a-zA-Z_]/)
+      end
+
+      def negative?
+        children[1] == :-@ && children[2].nil?
+      end
+
+      def negate?
+        children[1] == :!
+      end
+
+      def array_assignment?
+        children[1] == :[]=
+      end
+
+      def left_hand_mass_assignment?
+        parent&.type == :mlhs && method.to_s.end_with?("=")
+      end
+
+      def array_access?
+        children[1] == :[]
+      end
+
+      def called_on_heredoc?
+        child = target
+
+        while child&.type == :send || child&.string?
+          return true if child.string? && child.heredoc?
+          child = child.children[0]
+          return false unless child.respond_to?(:type)
+        end
+
+        false
+      end
+
+      def heredoc_arguments?
+        arguments.any? do |child|
+          child.string? && child.heredoc? || (child.type == :send && child.called_on_heredoc?)
+        end
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/str_node.rb

@@ -0,0 +1,18 @@
+module Prettyrb
+  module Nodes
+    class StrNode < BaseNode
+      include StringHelper
+
+      def format
+        raw_content = loc.expression.source
+        content = raw_content[1...-1]
+
+        if raw_content[0] == "'"
+          content.gsub('"', '\\"').gsub('#{', '\\#{')
+        else
+          content.gsub("\\", "\\\\")
+        end
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/string_helper.rb

@@ -0,0 +1,43 @@
+module Prettyrb
+  module Nodes
+    module StringHelper
+      HEREDOC_TYPE_REGEX = /<<([~-])?/
+
+      def percent_string?
+        loc.expression.source.start_with?("%")
+      end
+
+      def percent_character
+        loc.expression.source[1]
+      end
+
+      def start_delimiter
+        loc.expression.source[2]
+      end
+
+      def closing_delimiter
+        loc.expression.source.rstrip[-1]
+      end
+
+      def heredoc_identifier
+        loc.heredoc_end.source.strip
+      end
+
+      def heredoc_type
+        # Always use indentable ending heredoc type if no type was provided
+        #
+        # eg: <<RUBY becomes <<-RUBY since <<- allows the ending identifier
+        # to be indented
+        loc.expression.source.match(HEREDOC_TYPE_REGEX)[1] || "-"
+      end
+
+      def heredoc_body
+        loc.heredoc_body.source
+      end
+
+      def heredoc?
+        !!loc.respond_to?(:heredoc_body)
+      end
+    end
+  end
+end

data/lib/prettyrb/version.rb

@@ -1,3 +1,3 @@
 module Prettyrb
-  VERSION = "0.1.0"
+  VERSION = "0.5.0"
 end

data/lib/prettyrb/visitor.rb

@@ -0,0 +1,947 @@
+module Prettyrb
+  class Visitor
+    include Document::DSL
+
+    MAX_LENGTH = 100
+    SINGLE_LINE = "single_line"
+    MULTI_LINE = "multi_line"
+
+    FNAMES = [
+      "..",
+      "|",
+      "ˆ",
+      "&",
+      "<=>",
+      "==",
+      "===",
+      "=˜",
+      ">",
+      ">=",
+      "<",
+      "<=",
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "**",
+      "<<",
+      ">>",
+      "~",
+      "+@",
+      "-@",
+      "[]",
+      "[]="
+    ]
+    VALID_SYMBOLS = FNAMES + ["!", "!="]
+
+    def initialize(root_node)
+      @output = ""
+      @builder = visit(root_node)
+    end
+
+    def output
+      Writer.new(@builder).to_s
+    end
+
+    def visit(node)
+      case node.type
+      when :module
+        body = if node.children[1]
+          concat(
+            indent(
+              hardline,
+              visit(node.children[1]),
+            ),
+            hardline
+          )
+        end
+
+        concat(
+          "module ",
+          visit(node.children[0]),
+          body,
+          "end"
+        )
+      when :sclass
+        body = if node.children[1]
+          concat(
+            indent(
+              hardline,
+              visit(node.children[1]),
+            ),
+            hardline,
+          )
+        end
+
+        concat(
+          "class << ",
+          visit(node.children[0]),
+          body,
+          "end"
+        )
+      when :class
+        inheritance = if node.children[1]
+          concat(
+            " < ",
+            visit(node.children[1]),
+          )
+        end
+
+        content = if node.children[2]
+          indent(
+            hardline,
+            visit(node.children[2]),
+          )
+        end
+
+        concat(
+          "class ",
+          visit(node.children[0]),
+          inheritance,
+          content,
+          hardline,
+          "end"
+        )
+      when :if
+        body = if node.body_node
+          concat(
+            indent(
+              hardline,
+              visit(node.body_node),
+            ),
+          )
+        end
+
+        elsifs = if node.has_elsif?
+          [hardline] + node.elsif_branches.map do |elsif_branch|
+            concat(
+              "elsif ",
+              visit(elsif_branch.conditions),
+              indent(
+                hardline,
+                visit(elsif_branch.body_node)
+              ),
+              hardline,
+            )
+          end
+        end
+
+        else_content = if node.else_branch
+          starting_newline = if !node.has_elsif?
+            hardline
+          end
+          concat(
+            starting_newline,
+            "else",
+            indent(
+              hardline,
+              visit(node.else_branch)
+            ),
+            hardline,
+          )
+        else
+          hardline
+        end
+
+        concat(
+          node.unless_node? ? "unless" : "if",
+          " ",
+          visit(node.conditions),
+          body,
+          *elsifs,
+          else_content,
+          "end"
+        )
+      when :case
+        arguments = if node.children[0]
+          concat(
+            " ",
+            visit(node.children[0]),
+          )
+        end
+
+        cases = node.children[1..-1].map do |child|
+          if child && child.type != :when
+            concat(
+              hardline,
+              "else",
+              indent(
+                hardline,
+                visit(child)
+              ),
+            )
+          elsif child
+            visit child
+          end
+        end
+
+        concat(
+          "case",
+          arguments,
+          concat(*cases),
+          hardline,
+          "end"
+        )
+      when :when
+        arguments = node.children[0..-2].compact
+        body = if node.children.last
+          indent(
+            hardline,
+            visit(node.children.last)
+          )
+        end
+
+        arguments = if arguments.size > 0
+          join(
+            separator: ",",
+            parts: arguments.map do |arg|
+              concat(softline, visit(arg))
+            end
+          )
+        end
+
+        concat(
+          hardline,
+          group(
+            "when",
+            if_break(with_break: "", without_break: " "),
+            indent(
+              arguments,
+            ),
+          ),
+          body
+        )
+      when :const
+        output = []
+
+        child = node.children[0]
+        while child&.type == :const || child&.type == :cbase
+          output << child.children[1]
+          child = child.children[0]
+        end
+
+        (output.reverse + [node.children[1]]).join("::")
+      when :or
+        builder = concat(
+          visit(node.children[0]),
+          " ||",
+          if_break(with_break: "", without_break: " "),
+          softline,
+          visit(node.children[1]),
+        )
+
+        if node.parent&.type == :and || node.parent&.type == :or
+          builder
+        else
+          group(
+            indent(
+              builder
+            )
+          )
+        end
+      when :and
+        builder = concat(
+          visit(node.children[0]),
+          " &&",
+          if_break(with_break: "", without_break: " "),
+          softline,
+          visit(node.children[1]),
+        )
+
+        if node.parent&.type == :and || node.parent&.type == :or
+          builder
+        else
+          group(
+            indent(
+              builder
+            )
+          )
+        end
+      when :int, :float
+        node.children[0].to_s
+      when :return
+        if node.children[0]
+          group(
+            "return",
+            if_break(without_break: " ", with_break: ""),
+            indent(
+              softline,
+              visit(node.children[0]),
+              only_when_break: true
+            )
+          )
+        else
+          "return"
+        end
+      when :block
+        args = if node.children[1]&.children&.length > 0
+          concat(
+            " |",
+            visit(node.children[1]),
+            "|",
+          )
+        end
+
+        concat(
+          visit(node.children[0]),
+          " do",
+          args,
+          indent(
+            hardline,
+            visit(node.children[2]),
+          ),
+          hardline,
+          "end",
+        )
+      when :begin
+        needs_parens = (node.parent&.type == :if && node.parent.children[0] == node) ||
+          node.parent&.type == :or ||
+          node.parent&.type == :and ||
+          node.parent&.type == :send
+
+        if needs_parens
+          concat(
+            "(",
+            *visit_each(node.children), # TODO Split or softline?
+            ")"
+          )
+        else
+          children = []
+          node.children.each_with_index do |child, index|
+            children << visit(child)
+
+            next_child = node.children[index + 1]
+            excluded_types = [:class, :module, :sclass, :def, :defs]
+
+            if (excluded_types.include?(child.type) && node.children.last != child) ||
+                (next_child&.type != child.type && node.children.last != child)
+              children << hardline(count: 2)
+            elsif node.children.last != child
+              children << hardline
+            end
+          end
+
+          concat(*children)
+        end
+      when :defs
+        args_blocks = visit node.children[2] if node.children[2]
+
+        body = if node.children[3]
+          concat(
+            indent(
+              hardline,
+              visit(node.children[3]),
+            ),
+            hardline,
+          )
+        else
+          hardline
+        end
+
+        concat(
+          "def ",
+          visit(node.children[0]),
+          ".",
+          node.children[1],
+          args_blocks,
+          body,
+          "end"
+        )
+      when :def
+        args_blocks = visit node.args if node.args
+        body_blocks = visit node.body if node.body
+
+        body = if node.body
+          concat(
+            indent(
+              hardline,
+              body_blocks,
+            ),
+            hardline,
+          )
+        else
+          hardline
+        end
+
+        concat(
+          "def ",
+          # TODO possible break
+          node.name,
+          args_blocks,
+          body,
+          "end",
+        )
+      when :args
+        if node&.parent&.type == :block
+          group(
+            join(
+              separator: ",",
+              parts: node.children.map(&method(:visit)),
+            ),
+          )
+        elsif node.children.length > 0
+          group(
+            "(",
+            softline,
+            join(
+              separator: ",",
+              parts: node.children.map(&method(:visit)),
+            ),
+            softline,
+            ")"
+          )
+        else
+          nil
+        end
+      when :arg
+        node.children[0]
+      when :masgn
+        concat(
+          visit(node.children[0]),
+          " = ",
+          visit(node.children[-1])
+        )
+      when :mlhs
+        if node.parent&.type == :mlhs
+          concat(
+            "(",
+            join(separator: ",", parts: visit_each(node.children)),
+            ")"
+          )
+        else
+          join(separator: ",", parts: visit_each(node.children))
+        end
+      when :casgn
+        if !node.children[0].nil?
+          puts "FATAL: FIX CASGN FIRST ARGUMENT"
+          exit 1
+        end
+
+        # TODO test softline grouping on right side of `=`
+        group(
+          node.children[1],
+          " = ",
+          # if_break(with_break: "", without_break: " "),
+          # softline,
+          visit(node.children[2]),
+        )
+      when :lvasgn, :cvasgn, :ivasgn
+        right_blocks = visit node.children[1] if node.children[1]
+
+        if right_blocks
+          concat(
+            node.children[0].to_s,
+            " = ",
+            # TODO line break for long lines
+            right_blocks,
+          )
+        else
+          concat(
+            node.children[0].to_s,
+          )
+        end
+      when :send
+        if node.called_on_heredoc?
+          visit node.target
+        elsif node.array_assignment?
+          equals = if !node.left_hand_mass_assignment?
+            " = "
+          end
+
+          body = if node.children[3]
+            visit(node.children[3])
+          end
+
+          concat(
+            visit(node.target),
+            "[",
+            visit(node.children[2]),
+            "]", # TODO line split
+            equals,
+            body,
+          )
+        elsif node.array_access?
+          concat(
+            visit(node.target),
+            "[",
+            visit(node.children[2]),
+            "]"
+          )
+        elsif node.negate?
+          concat(
+            "!",
+            visit(node.target),
+          )
+        elsif node.negative?
+          concat(
+            "-",
+            visit(node.target),
+          )
+        elsif node.self_target?
+          body = visit(node.target) if node.target
+
+          concat(
+            node.method.to_s[0..-2],
+            body,
+          )
+        elsif node.infix?
+          body = visit(node.children[2]) if node.children[2]
+
+          group(
+            concat(
+              visit(node.target),
+              " ",
+              node.method,
+              " ",
+              body,
+            )
+          )
+        else
+          arguments = if node.arguments.length > 0
+            concat(
+              "(",
+              indent(
+                join(separator: ",", parts: node.arguments.map { |child| concat(softline, visit(child)) }),
+                only_when_break: true,
+              ),
+              softline,
+              ")",
+            )
+          end
+
+          method = if node.left_hand_mass_assignment?
+            node.method.to_s[0...-1]
+          else
+            node.method
+          end
+
+          if node.target
+            concat(
+              visit(node.target),
+              ".",
+              method,
+              group(
+                arguments,
+              )
+            )
+          else
+            concat(
+              method,
+              group(
+                arguments,
+              )
+            )
+          end
+        end
+      when :hash
+        if node.children.length > 0
+          group(
+            "{",
+            if_break(without_break: " ", with_break: ""),
+            indent(
+              join(separator: ",", parts: node.children.map { |child| concat(softline, visit(child)) }),
+              if_break(without_break: " ", with_break: ""),
+            ),
+            softline,
+            "}"
+          )
+        else
+          "{}"
+        end
+      when :pair
+        if node.children[0].type == :sym
+          concat(
+            visit(node.children[0]),
+            visit(node.children[1])
+          )
+        else
+          concat(
+            visit(node.children[0]),
+            " => ",
+            visit(node.children[1])
+          )
+        end
+      when :defined?
+        concat(
+          "defined?(",
+          visit(node.children[0]),
+          ")"
+        )
+      when :and_asgn, :or_asgn
+        operator = if node.type == :and_asgn
+          "&&="
+        elsif node.type == :or_asgn
+          "||="
+        end
+
+        group(
+          visit(node.children[0]),
+          " ",
+          operator,
+          if_break(with_break: "", without_break: " "),
+          softline,
+          visit(node.children[1])
+        )
+      when :array
+        if node.parent&.type == :resbody
+          join(separator: ",", parts: visit_each(node.children))
+        elsif node.children[0]&.type == :splat
+          visit node.children[0]
+        else
+          array_nodes = node.children.each_with_index.map do |child, index|
+            concat(softline, visit(child))
+          end
+
+          group(
+            "[",
+            indent(
+              join(separator: ",", parts: array_nodes),
+            ),
+            softline,
+            "]"
+          )
+        end
+      when :regopt
+        node.children.map(&:to_s).join("")
+      when :regexp
+        content = node.children[0...-1].map do |child|
+          if child.type == :str
+            child.children[0].to_s
+          else
+            visit child
+          end
+        end
+
+        options = if node.children[-1]
+          visit node.children[-1]
+        end
+
+        if node.percent?
+          concat(
+            "%",
+            node.percent_type,
+            node.start_delimiter,
+            *content,
+            node.end_delimiter,
+            options,
+          )
+        else
+          concat(
+            "/",
+            *content,
+            "/",
+            options,
+          )
+        end
+      when :str, :dstr
+        if node.heredoc?
+          method_calls = if node.parent&.type == :send
+            method_calls = []
+            parent = node.parent
+
+            while parent && parent.type == :send && parent.called_on_heredoc?
+              arguments = if parent.arguments.length > 0
+                concat(
+                  "(",
+                  join(separator: ",", parts: parent.arguments.map { |child| concat(softline, visit(child)) }),
+                  ")",
+                )
+              end
+
+              method_calls.push(
+                concat(
+                  ".",
+                  parent.children[1].to_s,
+                  arguments,
+                )
+              )
+              parent = parent.parent
+            end
+
+            concat(*method_calls)
+          end
+
+          concat(
+            "<<",
+            node.heredoc_type,
+            node.heredoc_identifier,
+            method_calls,
+            hardline(skip_indent: true),
+            node.heredoc_body,
+            node.heredoc_identifier
+          )
+        elsif node.percent_string?
+          body = node.children.map do |child|
+            if child.is_a?(String)
+              child
+            elsif child.type == :str
+              child.children[0]
+            else
+              visit child
+            end
+          end
+
+          concat(
+            "%",
+            node.percent_character,
+            node.start_delimiter,
+            *body,
+            node.closing_delimiter,
+          )
+        else
+          concat(
+            "\"",
+            node.format,
+            "\"",
+          )
+        end
+      when :alias
+        concat(
+          "alias ",
+          visit(node.children[0]),
+          " ",
+          visit(node.children[1]),
+        )
+      when :dsym
+        body = node.children.map do |child|
+          if child.string?
+            child.children[0]
+          else
+            concat(
+              "\#{",
+              visit(child),
+              "}",
+            )
+          end
+        end
+
+        concat(
+          ":\"",
+          *body,
+          "\"",
+        )
+      when :sym
+        content = node.children[0].to_s
+
+        # TODO handle already quoted symbols
+        if !VALID_SYMBOLS.include?(content) && !content.match?(/\A[a-zA-Z_]{1}[a-zA-Z0-9_!?=]*\z/)
+          concat(
+            ":",
+            "'",
+            content,
+            "'",
+          )
+        else
+          if node.parent&.type == :pair && node.parent.children[0] == node
+            concat(
+              content,
+              ": ",
+            )
+          else
+            concat(
+              ":",
+              content,
+            )
+          end
+        end
+      when :kwsplat
+        concat(
+          "**",
+          visit(node.children[0])
+        )
+      when :splat
+        concat(
+          "*",
+          visit(node.children[0])
+        )
+      when :undef
+        concat(
+          "undef",
+          " ",
+          join(separator: ",", parts: visit_each(node.children))
+        )
+      when :forward_args
+        "(...)"
+      when :forwarded_args
+        "..."
+      when :optarg
+        concat(
+          node.children[0],
+          " = ",
+          visit(node.children[1]),
+        )
+      when :restarg
+        concat(
+          "*",
+          node.children[0],
+        )
+      when :kwarg
+        concat(
+          node.children[0],
+          ":",
+        )
+      when :kwoptarg
+        concat(
+          node.children[0],
+          ": ",
+          visit(node.children[1]),
+        )
+      when :kwrestarg
+        if node.children[0]
+          "**" + node.children[0].to_s
+        else
+          "**"
+        end
+      when :kwnilarg
+        "**nil"
+      when :lvar, :cvar, :ivar, :gvar
+        node.children[0].to_s
+      when :true, :false, :nil, :self, :break
+        node.type.to_s
+      when :cbase
+        "::"
+      when :kwbegin
+        concat(
+          "begin",
+          indent(
+            hardline,
+            visit(node.children[0])
+          ),
+          hardline,
+          "end"
+        )
+      when :ensure
+        concat(
+          indent(
+            visit(node.children[0]),
+          ),
+          dedent(
+            hardline,
+            "ensure",
+          ),
+          hardline,
+          visit(node.children[1]),
+        )
+      when :rescue
+        concat(
+          visit(node.children[0]),
+          dedent(
+            hardline,
+            visit(node.children[1])
+          )
+        )
+      when :resbody
+        args = node.children[0]
+        assignment = node.children[1]
+        body = node.children[2]
+
+        arguments = if args
+          concat(
+            " ",
+            visit(args),
+          )
+        end
+
+        argument_assignment = if assignment
+          concat(
+            " => ",
+            visit(assignment)
+          )
+        end
+
+        body = if body
+          visit(body)
+        end
+
+        concat(
+          "rescue",
+          arguments,
+          argument_assignment,
+          indent(
+            hardline,
+            body,
+          )
+        )
+      when :while
+        args = if node.children[0]
+          concat(
+            " ",
+            visit(node.children[0])
+          )
+        end
+
+        body = if node.children[1]
+          indent(
+            hardline,
+            visit(node.children[1]),
+          )
+        end
+
+        concat(
+          "while",
+          args,
+          body,
+          hardline,
+          "end",
+        )
+      when :csend
+        concat(
+          visit(node.children[0]),
+          "&.", # TODO softbreak
+          node.children[1]
+        )
+      when :erange
+        right_side = visit(node.children[1]) if node.children[1]
+
+        concat(
+          visit(node.children[0]),
+          "...",
+          right_side
+        )
+      when :irange
+        right_side = visit(node.children[1]) if node.children[1]
+
+        concat(
+          visit(node.children[0]),
+          "..",
+          right_side
+        )
+      when :nth_ref
+        concat(
+          "$",
+          node.children[0].to_s,
+        )
+      when :super
+        concat(
+          "super(",
+          *visit_each(node.children),
+          ")"
+        )
+      when :next
+        body = if node.children[0]
+          concat(" ", visit(node.children[0]))
+        end
+
+        concat(
+          "next",
+          body
+        )
+      when :zsuper
+        "super"
+      when :block_pass
+        concat("&", visit(node.children[0]))
+      else
+        raise "Unexpected node type: #{node.type}"
+      end
+    end
+
+    private
+
+    def visit_each(node)
+      node.map do |child|
+        visit(child)
+      end
+    end
+  end
+end