prettyrb 0.4.0 → 0.5.0

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/string_helper.rb

@@ -1,7 +1,23 @@
 module Prettyrb
   module Nodes
     module StringHelper
-      HEREDOC_TYPE_REGEX = /<<(.)?/
+      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

data/lib/prettyrb/version.rb

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

data/lib/prettyrb/visitor.rb

@@ -1,5 +1,7 @@
 module Prettyrb
   class Visitor
+    include Document::DSL
+
     MAX_LENGTH = 100
     SINGLE_LINE = "single_line"
     MULTI_LINE = "multi_line"
@@ -33,730 +35,912 @@ module Prettyrb
     ]
     VALID_SYMBOLS = FNAMES + ["!", "!="]
 
-    attr_reader :output
-
-    def initialize
-      @indent_level = 0
-      @output = ""
-
-      @newline = true
-      @multiline_conditional_level = 0
-      @previous_node = nil
-      @current_line = ''
-    end
-
-    def indents
-      '  ' * @indent_level
-    end
-
-    def dedent(&block)
-      old_indent_level = @indent_level
-
-      @indent_level = [0, @indent_level - 1].max
-      yield
-      @indent_level = old_indent_level
-    end
-
-    def indent(&block)
-      old_indent_level = @indent_level
-      old_previous_node = @previous_node
-
-      @previous_node = nil
-      @indent_level += 1
-      value = yield
-      @indent_level = old_indent_level
-      @previous_node = old_previous_node
-      value
-    end
-
-    def multiline_conditional_level
-      @multiline_conditional_level
-    end
-
-    def in_multiline_conditional(&block)
-      old_multiline_condtiional_level = @multiline_conditional_level
-      @multiline_conditional_level += 1
-      @multiline_condtiional_level = 0
-      yield
-      @multiline_conditional_level = old_multiline_condtiional_level
-    end
-
-    def capture(&block)
-      old_newline = @newline
-      old_output = @output
-      old_current_line = @current_line
-
-      @current_line = ""
+    def initialize(root_node)
       @output = ""
-
-      yield
-
-      @output.tap do |output|
-        @output = old_output
-        @newline = old_newline
-        @current_line = old_current_line
-      end
+      @builder = visit(root_node)
     end
 
-    def newline
-      @output << "\n"
-      @newline = true
-      @current_line = ''
-    end
-
-    def write(input, skip_indent: false)
-      if @newline
-        @output << indents unless skip_indent
-        @current_line << indents unless skip_indent
-      end
-      @newline = false
-      @output << input
-      @current_line << input
+    def output
+      Writer.new(@builder).to_s
     end
 
     def visit(node)
       case node.type
       when :module
-        write "module "
-        visit node.children[0]
-        newline
-
-        indent do
-          visit node.children[1]
-        end
-
-        write "end"
-        newline
+        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
-        newline unless @previous_node.nil?
-        write "class "
-        visit node.children[0]
-        newline
-        # TODO handle children[1] which is inheritance
-
-        indent do
-          visit node.children[2] if node.children[2]
+        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
 
-        newline unless @output.end_with?("\n")
-        write "end"
-        newline
-      when :const
-        visit node.children[0] if node.children[0]
-        write node.children[1].to_s
-      when :casgn
-        write node.children[1].to_s
-        write " = "
-        visit node.children[2]
-      when :block
-        newline unless @previous_node.nil?
-        visit node.children[0]
-        write " do"
-
-        if node.children[1].children.length > 0
-          write " |"
-          visit node.children[1]
-          write "|"
+        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
 
-        newline
-
-        indent do
-          visit node.children[2]
+        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
 
-        newline
-
-        write "end"
-      when :send
-        newline if node.parent&.type == :begin && @previous_node && @previous_node&.type != :send
-        if node.children[0] == nil
-          write node.children[1].to_s
-
-          # TODO possible > MAX via `capture`
-          arguments = node.children[2..-1]
-          if arguments.length > 0
-            write "("
-            indent do
-              if splittable_separated_map(node, arguments) == MULTI_LINE
-                newline
-              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
-            write ")"
-          end
-
-          newline if @previous_node&.type == :class 
-        elsif node.children[1] == :[]
-          visit node.children[0]
-          write "["
-          visit node.children[2]
-          write "]"
-        elsif node.children[1] == :!
-          write "!"
-          visit node.children[0]
-        elsif node.children[1] == :-@ && node.children[2].nil?
-          write "-"
-          visit node.children[0]
-        elsif !node.children[1].to_s.match?(/[a-zA-Z]/)
-          visit node.children[0]
-          write " "
-          write node.children[1].to_s
-          write " "
-          visit node.children[2]
+          )
+        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
-          visit node.children[0]
-          write "."
-          write node.children[1].to_s
-
-          # TODO possible > MAX via `capture`
-          arguments = node.children[2..-1]
-          if arguments.length > 0
-            write "("
-            arguments.each_with_index do |child_node, index|
-              visit child_node
-              write ", " unless index == arguments.length - 1
-            end
-            write ")"
-          end
+          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 :if
-        newline if @previous_node && node.parent&.type != :if
-        conditions = node.conditions_node
-
-        write node.if_type
-
-        conditions = capture do
-          visit node.children[0]
+      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)
 
-        indent do
-          if !conditions.start_with?("\n")
-            write(" ")
-            write conditions
-          else
-            visit node.conditions_node
+            next_child = node.children[index + 1]
+            excluded_types = [:class, :module, :sclass, :def, :defs]
 
-            dedent do
-              newline
-              write "then"
+            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
 
-          newline
-          visit node.body_node
-        end
-
-        newline
-
-        if node.else_body_node
-          if node.has_elsif?
-            visit node.else_body_node
-          else
-            write "else"
-            newline
-
-            indent do
-              visit node.else_body_node
-            end
-
-            newline
-          end
+          concat(*children)
         end
+      when :defs
+        args_blocks = visit node.children[2] if node.children[2]
 
-        if !node.is_elsif?
-          write "end"
+        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
-      when :true
-        write "true"
-      when :false
-        write "false"
-      when :nil
-        write "nil"
-      when :int, :float
-        write node.children[0].to_s
-      when :next
-        write "next"
 
-        if node.children[0]
-          write " "
-          visit node.children[0]
+        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 :array
-        if node.children[0]&.type == :splat
-          visit node.children[0]
+      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
-          write "[" unless node.parent&.type == :resbody
-          if node.children.length > 0
-            indent do
-              result = splittable_separated_map(node, node.children)
-              newline if result == MULTI_LINE
-            end
-          end
-          write "]" unless node.parent&.type == :resbody
+          join(separator: ",", parts: visit_each(node.children))
         end
-      when :str
-        if node.heredoc?
-          if node&.parent&.type == :send
-            write "("
-          end
-          write "<<"
-          write node.heredoc_type if node.heredoc_type
-          write node.heredoc_identifier
-          newline
-          write node.heredoc_body, skip_indent: true
-          @newline = true
-          write node.heredoc_identifier
-
-          if node&.parent&.type == :send
-            newline
-            write ")"
-          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
-          write '"'
-          write node.format
-          write '"'
+          concat(
+            node.children[0].to_s,
+          )
         end
-      when :dstr
-        if node.heredoc?
-          if node&.parent&.type == :send
-            write "("
+      when :send
+        if node.called_on_heredoc?
+          visit node.target
+        elsif node.array_assignment?
+          equals = if !node.left_hand_mass_assignment?
+            " = "
           end
-          write "<<"
-          write node.heredoc_type if node.heredoc_type
-          write node.heredoc_identifier
-          newline
-          write node.heredoc_body, skip_indent: true
-          @newline = true
-          write node.heredoc_identifier
-
-          if node&.parent&.type == :send
-            newline
-            write ")"
+
+          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
-          write "\""
-          node.children.map do |child|
-            if child.type == :str
-              write child.format
-            else
-              write '#{'
-              visit child
-              write '}'
-            end
+          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
-          write "\""
-        end
-      when :begin
-        if @previous_node&.type == :or || @previous_node&.type == :and
-          write "("
-          @previous_node = nil
-          node.children.map do |child|
-            visit child
-            @previous_node = child
+
+          method = if node.left_hand_mass_assignment?
+            node.method.to_s[0...-1]
+          else
+            node.method
           end
-          @previous_node = nil
-          write ")"
-        else
-          @previous_node = nil
-          node.children.each_with_index do |child, index|
-            visit child
-            newline unless index == node.children.length - 1
-            @previous_node = child
+
+          if node.target
+            concat(
+              visit(node.target),
+              ".",
+              method,
+              group(
+                arguments,
+              )
+            )
+          else
+            concat(
+              method,
+              group(
+                arguments,
+              )
+            )
           end
-          @previous_node = nil
         end
-      when :or, :and
-        write "(" if node.parent&.type == :begin
-        possible_output = capture do
-          visit node.children[0]
-          if node.type == :or
-            write " || "
-          elsif node.type == :and
-            write " && "
-          end
-          visit node.children[1]
-        end
-        if @multiline_conditional_level > 0 # TODO track and check currently level
-          write_multiline_conditional(node)
-        elsif possible_output.length > MAX_LENGTH
-          in_multiline_conditional do
-            newline
-            write_multiline_conditional(node)
-          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
-          write possible_output
-        end
-        write ")" if node.parent&.type == :begin
-      when :def, :defs
-        newline unless @previous_node&.type.nil?
-        if node.type == :defs
-          write "def self."
-          method_name_node = node.children[1]
-          arguments_node = node.children[2]
-          body_node = node.children[3]
+          "{}"
+        end
+      when :pair
+        if node.children[0].type == :sym
+          concat(
+            visit(node.children[0]),
+            visit(node.children[1])
+          )
         else
-          write "def "
-          method_name_node = node.children[0]
-          arguments_node = node.children[1]
-          body_node = node.children[2]
+          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
 
-        write method_name_node.to_s
-
-        if arguments_node.children.length > 0 || arguments_node.type != :args
-          write "("
-          visit arguments_node
-          write ")"
+          group(
+            "[",
+            indent(
+              join(separator: ",", parts: array_nodes),
+            ),
+            softline,
+            "]"
+          )
         end
-        newline
-
-        if body_node
-          indent do
-            visit body_node
+      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
-
-          newline
         end
 
-        write "end"
-      when :args
-        node.children.each_with_index do |child, index|
-          visit child
-          write ", " unless index == node.children.length - 1
+        options = if node.children[-1]
+          visit node.children[-1]
         end
-      when :arg
-        write node.children[0].to_s
-      when :lvar, :gvar
-        write node.children[0].to_s
-      when :self
-        "self"
-      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/)
-          content = "'#{content}'"
-          write ":"
-          write content
+        if node.percent?
+          concat(
+            "%",
+            node.percent_type,
+            node.start_delimiter,
+            *content,
+            node.end_delimiter,
+            options,
+          )
         else
-          if node.parent&.type == :pair
-            write content
-            write ": "
-          else
-            write ":"
-            write content
-          end
-        end
-      when :return
-        write "return"
+          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
 
-        if node.children[0]
-          possible_output = capture do
-            visit node.children[0]
-          end
+              method_calls.push(
+                concat(
+                  ".",
+                  parent.children[1].to_s,
+                  arguments,
+                )
+              )
+              parent = parent.parent
+            end
 
-          if !possible_output.start_with?("\n")
-            write " "
+            concat(*method_calls)
           end
-        end
-      when :case
-        write "case "
-        visit node.children[0]
-        newline
-        node.children[1..-1].each do |child|
-          if child && child.type != :when
-            write "else"
-            newline
 
-            indent do
-              visit child
-            end
-          else
-            if child
+          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
-              newline
             end
           end
+
+          concat(
+            "%",
+            node.percent_character,
+            node.start_delimiter,
+            *body,
+            node.closing_delimiter,
+          )
+        else
+          concat(
+            "\"",
+            node.format,
+            "\"",
+          )
         end
-        write "end"
-      when :regexp
-        write '/'
-        node.children[0...-1].map do |child_node|
-          if child_node.type == :str
-            write child_node.children[0].to_s
+      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
-            visit child_node
+            concat(
+              "\#{",
+              visit(child),
+              "}",
+            )
           end
         end
-        write '/'
-        visit node.children[-1]
-      when :regopt
-        node.children.map { |child| child.to_s }.join('')
-      when :when
-        write "when"
-
-        indent do
-          splittable_separated_map(node, node.children[0..-2], skip_last_multiline_separator: true, write_space_if_single_line: true)
-        end
 
-        newline
-        indent do
-          visit node.children[-1]
-        end
-      when :or_asgn, :and_asgn
-        newline if @previous_node && ![:ivasgn, :or_asgn, :lvasgn, :op_asgn].include?(@previous_node.type)
-        visit node.children[0]
-        if node.type == :or_asgn
-          write " ||= " # TODO handle long lines here too
-        elsif node.type == :and_asgn
-          write " &&= " # TODO handle long lines here too
-        end
-        visit node.children[1]
-      when :ivasgn
-        newline if @previous_node && ![:ivasgn, :or_asgn, :lvasgn, :op_asgn].include?(@previous_node.type)
-        write node.children[0].to_s
+        concat(
+          ":\"",
+          *body,
+          "\"",
+        )
+      when :sym
+        content = node.children[0].to_s
 
-        if node.children[1]
-          write " = "
-          visit node.children[1]
-        end
-      when :csend
-        visit node.children[0]
-        write "&."
-        write node.children[1].to_s
-      when :ivar
-        write node.children[0].to_s
-      when :blockarg
-        write '&'
-        write node.children[0].to_s
-      when :yield
-        newline unless @previous_node.nil? || [:op_asgn, :lvasgn, :or_asgn, :and_asgn].include?(@previous_node.type)
-        write "yield"
-      when :op_asgn
-        newline if @previous_node && ![:ivasgn, :or_asgn, :lvasgn, :op_asgn].include?(@previous_node.type)
-        visit node.children[0]
-        write " "
-        write node.children[1].to_s
-        write "="
-        write " "
-        visit node.children[2]
-      when :lvasgn
-        newline if @previous_node && ![:ivasgn, :or_asgn, :lvasgn, :op_asgn].include?(@previous_node.type)
-        write node.children[0].to_s
-        if node.children[1]
-          write " = "
-          visit node.children[1]
-        end
-      when :irange
-        visit node.children[0] unless node.children[0].nil?
-        write ".."
-        visit node.children[1] unless node.children[1].nil?
-      when :erange
-        visit node.children[0] unless node.children[0].nil?
-        write "..."
-        visit node.children[1] unless node.children[1].nil?
-      when :hash
-        if node.children.length == 0
-          write "{}"
+        # 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
-          write "{"
-
-          result = indent do
-            splittable_separated_map(node, node.children, write_space_if_single_line: true)
-          end
-
-          if result == MULTI_LINE
-            newline
-            write "}"
+          if node.parent&.type == :pair && node.parent.children[0] == node
+            concat(
+              content,
+              ": ",
+            )
           else
-            write " }"
+            concat(
+              ":",
+              content,
+            )
           end
         end
-      when :pair
-        visit node.children[0]
-        if node.children[0].type != :sym
-          write " => "
-        end
-        visit node.children[1]
+      when :kwsplat
+        concat(
+          "**",
+          visit(node.children[0])
+        )
       when :splat
-        write "*"
-        visit node.children[0]
-      when :defined?
-        write "defined?("
-        visit node.children[0]
-        write ")"
-      when :complex,
-        :dsym,
-        :xstr,
-        :'nth-ref',
-        :'back-ref',
-        :gvasgn,
-        :procarg0,
-        :shadowarg
-        raise "implement me, #{node.inspect}"
-      when :sclass
-        write "class << "
-        visit node.children[0]
-        newline
-
-        indent do
-          visit node.children[1] if node.children[1]
-        end
-
-        newline if node.children[1]
-        write "end"
+        concat(
+          "*",
+          visit(node.children[0])
+        )
       when :undef
-        write "undef "
-        node.children.each_with_index do |child_node, index|
-          visit child_node
-          write ", " unless index == node.children.length - 1
-        end
-      when :alias
-        write 'alias '
-        visit node.children[0]
-        write ' '
-        visit node.children[1]
-      when :restarg
-        write "*"
-        write node.children[0].to_s
+        concat(
+          "undef",
+          " ",
+          join(separator: ",", parts: visit_each(node.children))
+        )
+      when :forward_args
+        "(...)"
+      when :forwarded_args
+        "..."
       when :optarg
-        write node.children[0].to_s
-        write " = "
-        visit node.children[1]
-      when :kwsplat
-        write "**"
-        visit node.children[0]
+        concat(
+          node.children[0],
+          " = ",
+          visit(node.children[1]),
+        )
+      when :restarg
+        concat(
+          "*",
+          node.children[0],
+        )
       when :kwarg
-        write node.children[0].to_s
-        write ":"
-      when :forward_args, :forwarded_args
-        write "..."
+        concat(
+          node.children[0],
+          ":",
+        )
       when :kwoptarg
-        write node.children[0].to_s
-        write ": "
-        visit node.children[1]
+        concat(
+          node.children[0],
+          ": ",
+          visit(node.children[1]),
+        )
       when :kwrestarg
-        write "**"
-        write node.children[0].to_s if node.children[0]
+        if node.children[0]
+          "**" + node.children[0].to_s
+        else
+          "**"
+        end
       when :kwnilarg
-        write "**nil"
+        "**nil"
+      when :lvar, :cvar, :ivar, :gvar
+        node.children[0].to_s
+      when :true, :false, :nil, :self, :break
+        node.type.to_s
       when :cbase
-        write "::"
-      when :zsuper
-        write "super"
-      when :nth_ref
-        write "$"
-        write node.children[0].to_s
-      when :masgn
-        left = node.children[0...-1]
-        right = node.children[-1]
-
-        left.each_with_index do |child_node, index|
-          visit child_node
-        end
-
-        write " = "
-        visit right
-      when :mlhs
-        write "(" if node.parent&.type == :mlhs
-        node.children.each_with_index do |child_node, index|
-          visit child_node
-          write ", " unless index == node.children.length - 1
-        end
-        write ")" if node.parent&.type == :mlhs
-      when :block_pass
-        write "&"
-        visit node.children[0]
+        "::"
       when :kwbegin
-        write "begin"
-        newline
-        indent do
-          visit node.children[0]
-        end
-        newline
-        write "end"
+        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
-        visit node.children[0]
-        newline
-
-        dedent do
-          write "rescue"
-          visit node.children[1]
-        end
+        concat(
+          visit(node.children[0]),
+          dedent(
+            hardline,
+            visit(node.children[1])
+          )
+        )
       when :resbody
-        if node.children[0]
-          write " "
-          visit node.children[0] if node.children[0]
-        end
-
-        if node.children[1]
-          write " => "
-          write node.children[1].children[0].to_s
-        end
-        newline
+        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]
 
-        indent do
-          visit node.children[2] if node.children[2]
-        end
-      when :ensure
-        visit node.children[0] if node.children[0]
-        newline
+        concat(
+          visit(node.children[0]),
+          "...",
+          right_side
+        )
+      when :irange
+        right_side = visit(node.children[1]) if node.children[1]
 
-        dedent do
-          write "ensure"
+        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
 
-        newline
-        visit node.children[1] if node.children[1]
-      else
-        raise "unhandled node type `#{node.type}`\nnode: #{node}"
-      end
-    end
-
-    def write_multiline_conditional(node)
-      visit node.children[0]
-
-      if node.type == :or
-        write " ||"
-      elsif node.type == :and
-        write " &&"
-      end
-
-      newline
-
-      visit node.children[1]
-    end
-
-    def format_string(string)
-      raw_content = string.loc.expression.source
-      content = raw_content[1...-1]
-
-      if raw_content[0] == "'"
-        content.gsub('"', '\\"').gsub('#{', '\\#{')
+        concat(
+          "next",
+          body
+        )
+      when :zsuper
+        "super"
+      when :block_pass
+        concat("&", visit(node.children[0]))
       else
-        content.gsub("\\", "\\\\")
+        raise "Unexpected node type: #{node.type}"
       end
     end
 
-    def splittable_separated_map(current_node, mappable, separator: ", ", skip_last_multiline_separator: false, write_space_if_single_line: false)
-      one_line = capture do
-        mappable.each_with_index do |child_node, index|
-          visit child_node
-          write separator unless index == mappable.length - 1
-        end
-      end
+    private
 
-      if @current_line.length + one_line.length > MAX_LENGTH
-        mappable.each_with_index do |child_node, index|
-          newline
-          visit child_node
-          write separator.rstrip unless skip_last_multiline_separator && index == mappable.length - 1
-        end
-        MULTI_LINE
-      else
-        write ' ' if write_space_if_single_line
-        write one_line
-        SINGLE_LINE
+    def visit_each(node)
+      node.map do |child|
+        visit(child)
       end
     end
   end