rufo 0.1.0 → 0.2.0

data/lib/rufo.rb

@@ -13,6 +13,6 @@ end
 require_relative "rufo/backport"
 require_relative "rufo/command"
 require_relative "rufo/dot_file"
+require_relative "rufo/settings"
 require_relative "rufo/formatter"
-require_relative "rufo/formatter/settings"
 require_relative "rufo/version"

data/lib/rufo/command.rb

@@ -8,14 +8,29 @@ class Rufo::Command
   CODE_CHANGE = 3
 
   def self.run(argv)
-    want_check, filename_for_dot_rufo = parse_options(argv)
-    new(want_check, filename_for_dot_rufo).run(argv)
+    want_check, exit_code, filename_for_dot_rufo = parse_options(argv)
+    new(want_check, exit_code, filename_for_dot_rufo).run(argv)
   end
 
-  def initialize(want_check, filename_for_dot_rufo)
+  def initialize(want_check, exit_code, filename_for_dot_rufo)
     @want_check = want_check
+    @exit_code = exit_code
     @filename_for_dot_rufo = filename_for_dot_rufo
     @dot_file = Rufo::DotFile.new
+    @squiggly_warning_files = []
+  end
+
+  def exit_code(status_code)
+    if @exit_code
+      status_code
+    else
+      case status_code
+      when CODE_OK, CODE_CHANGE
+        0
+      else
+        1
+      end
+    end
   end
 
   def run(argv)
@@ -24,8 +39,7 @@ class Rufo::Command
                   else
                     format_args argv
                   end
-
-    exit status_code
+    exit exit_code(status_code)
   end
 
   def format_stdin
@@ -71,6 +85,8 @@ class Rufo::Command
       syntax_error |= result == CODE_ERROR
     end
 
+    STDERR.puts squiggly_heredoc_warning unless @squiggly_warning_files.empty?
+
     case
     when syntax_error then CODE_ERROR
     when changed      then CODE_CHANGE
@@ -78,11 +94,34 @@ class Rufo::Command
     end
   end
 
+  def squiggly_heredoc_warning
+    <<-EOF
+Rufo Warning!
+  File#{squiggly_pluralize} #{squiggly_warning_files} #{squiggly_pluralize(:has)} not been formatted due to a problem with Ruby version #{RUBY_VERSION}
+  Please update to Ruby #{backported_version} to fix your formatting!
+  See https://github.com/ruby-formatter/rufo/wiki/Squiggly-Heredocs for information.
+    EOF
+  end
+
+  def squiggly_pluralize(x = :s)
+    idx = x == :s ? 0 : 1
+    (@squiggly_warning_files.length > 1 ? ["s", "have"] : ["", "has"])[idx]
+  end
+
+  def squiggly_warning_files
+    @squiggly_warning_files.join(', ')
+  end
+
+  def backported_version
+    return "2.3.5" if RUBY_VERSION[0..2] == "2.3"
+    "2.4.2"
+  end
+
   def format_file(filename)
     code = File.read(filename)
 
     begin
-      result = format(code, File.dirname(filename))
+      result = format(code, @filename_for_dot_rufo || File.dirname(filename))
     rescue Rufo::SyntaxError
       # We ignore syntax errors as these might be template files
       # with .rb extension
@@ -94,8 +133,12 @@ class Rufo::Command
       if @want_check
         STDERR.puts "Formatting #{filename} produced changes"
       else
-        File.write(filename, result)
-        puts "Format: #{filename}"
+        unless @squiggly_warning
+          File.write(filename, result)
+          puts "Format: #{filename}"
+        else
+          @squiggly_warning_files << filename
+        end
       end
 
       return CODE_CHANGE
@@ -112,24 +155,21 @@ class Rufo::Command
   end
 
   def format(code, dir)
+    @squiggly_warning = false
     formatter = Rufo::Formatter.new(code)
 
-    dot_rufo = @dot_file.find_in(dir)
-    if dot_rufo
-      begin
-        formatter.instance_eval(dot_rufo)
-      rescue => ex
-        STDERR.puts "Error evaluating #{dot_rufo}"
-        raise ex
-      end
+    options = @dot_file.get_config_in(dir)
+    unless options.nil?
+      formatter.init_settings(options)
     end
-
     formatter.format
-    formatter.result
+    result = formatter.result
+    @squiggly_warning = true if formatter.squiggly_flag
+    result
   end
 
   def self.parse_options(argv)
-    want_check = false
+    exit_code, want_check = true, false
     filename_for_dot_rufo = nil
 
     OptionParser.new do |opts|
@@ -144,12 +184,16 @@ class Rufo::Command
         filename_for_dot_rufo = value
       end
 
+      opts.on("-x", "--simple-exit", "Return 1 in the case of failure, else 0") do
+        exit_code = false
+      end
+
       opts.on("-h", "--help", "Show this help") do
         puts opts
         exit
       end
     end.parse!(argv)
 
-    [want_check, filename_for_dot_rufo]
+    [want_check, exit_code, filename_for_dot_rufo]
   end
 end

data/lib/rufo/dot_file.rb

@@ -5,12 +5,38 @@ class Rufo::DotFile
     @cache = {}
   end
 
+  def get_config_in(dir)
+    dot_rufo = find_in(dir)
+    if dot_rufo
+      return parse(dot_rufo)
+    end
+  end
+
   def find_in(dir)
     @cache.fetch(dir) do
       @cache[dir] = internal_find_in(dir)
     end
   end
 
+  def parse(file_contents)
+    file_contents.lines
+                 .map { |s| s.strip.split(/\s+/, 2) }
+                 .each_with_object({}) do |(name, value), acc|
+      value ||= ''
+      if value.start_with?(':')
+        value = value[1..-1].to_sym
+      elsif value == 'true'
+        value = true
+      elsif value == 'false'
+        value = false
+      else
+        $stderr.puts "Unknown config value=#{value.inspect} for #{name.inspect}"
+        next
+      end
+      acc[name.to_sym] = value
+    end
+  end
+
   def internal_find_in(dir)
     dir = File.expand_path(dir)
     file = File.join(dir, ".rufo")

data/lib/rufo/formatter.rb

@@ -3,6 +3,12 @@
 require "ripper"
 
 class Rufo::Formatter
+  include Rufo::Settings
+
+  INDENT_SIZE = 2
+
+  attr_reader :squiggly_flag
+
   def self.format(code, **options)
     formatter = new(code, **options)
     formatter.format
@@ -10,6 +16,7 @@ class Rufo::Formatter
   end
 
   def initialize(code, **options)
+    @squiggly_flag = false
     @code = code
     @tokens = Ripper.lex(code).reverse!
     @sexp = Ripper.sexp(code)
@@ -55,7 +62,6 @@ class Rufo::Formatter
 
     # Are we inside a type body?
     @inside_type_body = false
-    @visibility_indent_in_action = {}
 
     # Map lines to commands that start at the begining of a line with the following info:
     # - line indent
@@ -140,9 +146,6 @@ class Rufo::Formatter
     # and once we align the first one we fix the other ones.
     @assignments_ranges = {}
 
-    # Hash keys positions
-    @hash_keys_positions = []
-
     # Case when positions
     @case_when_positions = []
 
@@ -167,10 +170,7 @@ class Rufo::Formatter
 
     dedent_calls
     indent_literals
-    do_align_assignments if @align_assignments
-    do_align_hash_keys if @align_hash_keys
-    do_align_case_when if @align_case_when
-    do_align_comments if @align_comments
+    do_align_case_when if align_case_when
     remove_lines_before_inline_declarations
   end
 
@@ -231,11 +231,15 @@ class Rufo::Formatter
     when :@tstring_content
       # [:@tstring_content, "hello ", [1, 1]]
       heredoc, tilde = @current_heredoc
-      column = node[2][0]
-
+      if heredoc && tilde && broken_ripper_version?
+        @squiggly_flag = true
+      end
       # For heredocs with tilde we sometimes need to align the contents
       if heredoc && tilde && @last_was_newline
-        write_indent(next_indent) unless current_token_value == "\n"
+        unless (current_token_value == "\n" ||
+                current_token_kind == :on_heredoc_end)
+          write_indent(next_indent)
+        end
         skip_ignored_space
         if current_token_kind == :on_tstring_content
           check :on_tstring_content
@@ -243,7 +247,13 @@ class Rufo::Formatter
           next_token
         end
       else
-        consume_token :on_tstring_content
+        while (current_token_kind == :on_ignored_sp) ||
+              (current_token_kind == :on_tstring_content) ||
+              (current_token_kind == :on_embexpr_beg)
+          check current_token_kind
+          break if current_token_kind == :on_embexpr_beg
+          consume_token current_token_kind
+        end
       end
     when :string_content
       # [:string_content, exp]
@@ -317,7 +327,6 @@ class Rufo::Formatter
       # [:vcall, exp]
       token_column = current_token_column
       visit node[1]
-      adjust_visibility_indent(node[1], token_column)
     when :fcall
       # [:fcall, [:@ident, "foo", [1, 0]]]
       visit node[1]
@@ -447,6 +456,8 @@ class Rufo::Formatter
       visit_mlhs_add_star(node)
     when :rest_param
       visit_rest_param(node)
+    when :kwrest_param
+      visit_kwrest_param(node)
     when :retry
       # [:retry]
       consume_keyword "retry"
@@ -649,6 +660,9 @@ class Rufo::Formatter
     # [:string_embexpr, exps]
     consume_token :on_embexpr_beg
     skip_space_or_newline
+    if current_token_kind == :on_tstring_content
+      next_token
+    end
     visit_exps(node[1], with_lines: false)
     skip_space_or_newline
     consume_token :on_embexpr_end
@@ -722,7 +736,7 @@ class Rufo::Formatter
     line = @line
 
     visit target
-    consume_one_dynamic_space @spaces_around_equal, force_one: @align_assignments
+    consume_space
 
     track_assignment
     consume_op "="
@@ -740,7 +754,7 @@ class Rufo::Formatter
     line = @line
 
     visit target
-    consume_one_dynamic_space @spaces_around_equal, force_one: @align_assignments
+    consume_space
 
     # [:@op, "+=", [1, 2]],
     check :on_op
@@ -772,11 +786,7 @@ class Rufo::Formatter
       first_space = skip_space
     end
 
-    if @align_assignments
-      write_space
-    else
-      write_space_using_setting(first_space, @spaces_around_equal)
-    end
+    write_space_using_setting(first_space, :one)
 
     track_assignment
     consume_op "="
@@ -799,11 +809,9 @@ class Rufo::Formatter
         visit(value)
       end
     else
-      want_space = first_space || @spaces_around_equal == :one
       indent_after_space value, sticky: sticky,
-                                want_space: want_space,
-                                first_space: first_space,
-                                preserve_whitespace: @spaces_around_equal == :dynamic && !@align_assignments
+                                want_space: true,
+                                first_space: first_space
     end
   end
 
@@ -846,12 +854,6 @@ class Rufo::Formatter
     track_alignment :assign, @assignments_positions, offset
   end
 
-  def track_hash_key
-    return unless @current_hash
-
-    track_alignment :hash_key, @hash_keys_positions, 0, @current_hash.object_id
-  end
-
   def track_case_when
     track_alignment :case_whem, @case_when_positions
   end
@@ -876,13 +878,13 @@ class Rufo::Formatter
     _, cond, then_body, else_body = node
 
     visit cond
-    consume_one_dynamic_space @spaces_in_ternary
+    consume_space
     consume_op "?"
-    consume_one_dynamic_space_or_newline @spaces_in_ternary
+    consume_space_or_newline
     visit then_body
-    consume_one_dynamic_space @spaces_in_ternary
+    consume_space
     consume_op ":"
-    consume_one_dynamic_space_or_newline @spaces_in_ternary
+    consume_space_or_newline
     visit else_body
   end
 
@@ -899,9 +901,9 @@ class Rufo::Formatter
     end
 
     visit body
-    consume_one_dynamic_space @spaces_in_suffix
+    consume_space
     consume_keyword(suffix)
-    consume_one_dynamic_space_or_newline @spaces_in_suffix
+    consume_space_or_newline
     visit cond
   end
 
@@ -917,8 +919,8 @@ class Rufo::Formatter
     if newline? || comment?
       consume_end_of_line
 
-      # If align_chained_calls if off, we still want to preserve alignment if it's already there
-      if @align_chained_calls || (@original_dot_column && @original_dot_column == current_token_column)
+      # If align_chained_calls is off, we still want to preserve alignment if it's already there
+      if align_chained_calls || (@original_dot_column && @original_dot_column == current_token_column)
         @name_dot_column = @dot_column || next_indent
         write_indent(@dot_column || next_indent)
       else
@@ -928,7 +930,7 @@ class Rufo::Formatter
         write_indent(next_indent)
       end
     else
-      write_space_using_setting(first_space, @spaces_around_dot)
+      write_space_using_setting(first_space, :no)
     end
 
     # Remember dot column, but only if there isn't one already set
@@ -939,7 +941,7 @@ class Rufo::Formatter
 
     consume_call_dot
 
-    skip_space_or_newline_using_setting(@spaces_around_dot, next_indent)
+    skip_space_or_newline_using_setting(:no, next_indent)
 
     if name == :call
       # :call means it's .()
@@ -1030,7 +1032,7 @@ class Rufo::Formatter
 
       if found_comma
         if needs_trailing_newline
-          write "," if @trailing_commas != :never && !block_arg
+          write "," if trailing_commas && !block_arg
 
           next_token
           indent(next_indent) do
@@ -1045,7 +1047,7 @@ class Rufo::Formatter
 
       if newline? || comment?
         if needs_trailing_newline
-          write "," if @trailing_commas == :always && want_trailing_comma
+          write "," if trailing_commas && want_trailing_comma
 
           indent(next_indent) do
             consume_end_of_line
@@ -1056,7 +1058,7 @@ class Rufo::Formatter
         end
       else
         if needs_trailing_newline && !found_comma
-          write "," if @trailing_commas == :always && want_trailing_comma
+          write "," if trailing_commas && want_trailing_comma
           consume_end_of_line
           write_indent
         end
@@ -1071,6 +1073,9 @@ class Rufo::Formatter
       call_info << @line
     end
 
+    if @last_was_heredoc
+      write_line
+    end
     consume_token :on_rparen
   end
 
@@ -1118,6 +1123,8 @@ class Rufo::Formatter
       @current_heredoc = nil
       printed = true
     end
+
+    @last_was_heredoc = true if printed
   end
 
   def visit_command_call(node)
@@ -1167,7 +1174,7 @@ class Rufo::Formatter
       write_line
       write_indent(next_indent)
     else
-      write_space_using_setting(first_space, @spaces_in_commands)
+      write_space_using_setting(first_space, :one)
     end
   end
 
@@ -1232,7 +1239,7 @@ class Rufo::Formatter
       #
       #     foo 1,
       #         2
-    elsif !args_is_def_class_or_module && @first_token_in_line && base_column + @indent_size == @first_token_in_line[0][1]
+    elsif !args_is_def_class_or_module && @first_token_in_line && base_column + INDENT_SIZE == @first_token_in_line[0][1]
       # Otherwise, align it just by two spaces (so we need to dedent, we fake a dedent here)
       #
       #     foo 1,
@@ -1250,7 +1257,7 @@ class Rufo::Formatter
     visit call
 
     if block[0] == :brace_block
-      consume_one_dynamic_space @spaces_around_block_brace
+      consume_space
     else
       consume_space
     end
@@ -1272,7 +1279,7 @@ class Rufo::Formatter
     if void_exps?(body)
       consume_token :on_lbrace
       consume_block_args args
-      consume_one_dynamic_space @spaces_around_block_brace
+      consume_space
       consume_token :on_rbrace
       return
     end
@@ -1283,14 +1290,14 @@ class Rufo::Formatter
     if current_token_line == closing_brace_token[0][0]
       consume_token :on_lbrace
       consume_block_args args
-      consume_one_dynamic_space @spaces_around_block_brace
+      consume_space
       visit_exps body, with_lines: false
 
       while semicolon?
         next_token
       end
 
-      consume_one_dynamic_space @spaces_around_block_brace
+      consume_space
 
       consume_token :on_rbrace
       return
@@ -1337,7 +1344,7 @@ class Rufo::Formatter
 
   def consume_block_args(args)
     if args
-      consume_one_dynamic_space_or_newline @spaces_around_block_brace
+      consume_space_or_newline
       # + 1 because of |...|
       #                ^
       indent(@column + 1) do
@@ -1470,7 +1477,7 @@ class Rufo::Formatter
 
     line = @line
 
-    indent_body body, want_multiline: inside_type_body && @double_newline_inside_type == :dynamic
+    indent_body body
 
     while rescue_body
       # [:rescue, type, name, body, more_rescue]
@@ -1512,11 +1519,6 @@ class Rufo::Formatter
       indent_body ensure_body[1]
     end
 
-    if inside_type_body && current_type && @visibility_indent_in_action[current_type]
-      @indent -= @indent_size
-      @visibility_indent_in_action.delete current_type
-    end
-
     write_indent if @line != line
     consume_keyword "end"
   end
@@ -1614,6 +1616,13 @@ class Rufo::Formatter
     consume_space
 
     visit_comma_separated_list to_ary(var)
+    skip_space
+    if comma?
+      check :on_comma
+      write ','
+      next_token
+      skip_space_or_newline
+    end
 
     consume_space
     consume_keyword "in"
@@ -1664,9 +1673,9 @@ class Rufo::Formatter
     needs_indent = false
 
     if newline? || comment?
+      indent { consume_end_of_line }
       needs_indent = true
       base_column = next_indent
-      consume_end_of_line
       write_indent(base_column)
     else
       base_column = @column
@@ -1688,7 +1697,7 @@ class Rufo::Formatter
       check :on_comma
       write ","
       next_token
-      skip_space_or_newline_using_setting(@spaces_after_comma, base_column || @indent)
+      skip_space_or_newline_using_setting(:one, base_column || @indent)
     end
   end
 
@@ -1734,21 +1743,27 @@ class Rufo::Formatter
     end
   end
 
+  def visit_kwrest_param(node)
+    # [:kwrest_param, name]
+
+    _, name = node
+
+    if name
+      skip_space_or_newline
+      visit name
+    end
+  end
+
   def visit_unary(node)
     # [:unary, :-@, [:vcall, [:@ident, "x", [1, 2]]]]
     _, op, exp = node
 
     consume_op_or_keyword op
 
-    setting = op == :not ? @spaces_in_commands : @spaces_around_unary
+    setting = op == :not ? :one : :no
 
     first_space = space?
-    consume_space = first_space && setting == :dynamic
-    if consume_space
-      consume_space(want_preserve_whitespace: true)
-    else
-      skip_space_or_newline
-    end
+    skip_space_or_newline
 
     if op == :not
       has_paren = current_token_kind == :on_lparen
@@ -1804,10 +1819,8 @@ class Rufo::Formatter
       write " \\"
       write_line
       write_indent(next_indent)
-    elsif first_space && @spaces_around_binary == :dynamic
-      write_space first_space[2]
     else
-      write_space if needs_space
+      write_space
     end
 
     consume_op_or_keyword op
@@ -1819,14 +1832,9 @@ class Rufo::Formatter
                          want_space: needs_space,
                          needed_indent: needed_indent,
                          token_column: token_column,
-                         base_column: base_column,
-                         preserve_whitespace: @spaces_around_binary == :dynamic
+                         base_column: base_column
     else
-      if @spaces_around_binary == :one
-        write " " if needs_space
-      elsif first_space
-        write_space first_space[2]
-      end
+      write_space
       visit right
     end
   end
@@ -1940,11 +1948,8 @@ class Rufo::Formatter
         skip_space_or_newline
         check :on_rparen
         next_token
-        write_space_using_setting(first_space, @spaces_after_method_name)
         write "()"
       else
-        write_space_using_setting(first_space, @spaces_after_method_name)
-
         write "("
 
         if newline? || comment?
@@ -1966,14 +1971,14 @@ class Rufo::Formatter
         next_token
       end
     elsif !empty_params?(params)
-      if @parens_in_def == :yes
+      if parens_in_def == :yes
         write "("
       else
         write_space
       end
 
       visit params
-      write ")" if @parens_in_def == :yes
+      write ")" if parens_in_def == :yes
       skip_space
     end
 
@@ -2019,9 +2024,9 @@ class Rufo::Formatter
       write_params_comma if needs_comma
       visit_comma_separated_list(args_with_default) do |arg, default|
         visit arg
-        consume_one_dynamic_space @spaces_around_equal
+        consume_space
         consume_op "="
-        consume_one_dynamic_space @spaces_around_equal
+        consume_space
         visit default
       end
       needs_comma = true
@@ -2058,7 +2063,6 @@ class Rufo::Formatter
         skip_space_or_newline
         if value
           consume_space
-          track_hash_key
           visit value
         end
       end
@@ -2091,7 +2095,7 @@ class Rufo::Formatter
     check :on_comma
     write ","
     next_token
-    skip_space_or_newline_using_setting(@spaces_after_comma)
+    skip_space_or_newline_using_setting(:one)
   end
 
   def visit_array(node)
@@ -2235,15 +2239,13 @@ class Rufo::Formatter
     arrow = symbol || !(key[0] == :@label || key[0] == :dyna_symbol)
 
     visit key
-    consume_one_dynamic_space @spaces_around_hash_arrow
-
-    track_hash_key
+    consume_space
 
     # Don't output `=>` for keys that are `label: value`
     # or `"label": value`
     if arrow
       consume_op "=>"
-      consume_one_dynamic_space @spaces_around_hash_arrow, force_one: @align_hash_keys
+      consume_space
     end
 
     visit value
@@ -2329,7 +2331,7 @@ class Rufo::Formatter
           skip_space_or_newline
         end
       else
-        write_space_using_setting(first_space, @spaces_inside_array_bracket)
+        write_space_using_setting(first_space, :never)
         needed_indent = column
       end
 
@@ -2340,7 +2342,7 @@ class Rufo::Formatter
       end
     end
 
-    skip_space_or_newline_using_setting(@spaces_inside_array_bracket)
+    skip_space_or_newline_using_setting(:never)
 
     check :on_rbracket
     write "]"
@@ -2377,7 +2379,7 @@ class Rufo::Formatter
 
     visit receiver
 
-    skip_space_or_newline_using_setting(@spaces_around_dot, @dot_column || next_indent)
+    skip_space_or_newline_using_setting(:no, @dot_column || next_indent)
 
     # Remember dot column
     dot_column = @column
@@ -2385,7 +2387,7 @@ class Rufo::Formatter
 
     consume_call_dot
 
-    skip_space_or_newline_using_setting(@spaces_around_dot, next_indent)
+    skip_space_or_newline_using_setting(:no, next_indent)
 
     visit name
 
@@ -2438,7 +2440,7 @@ class Rufo::Formatter
     next_token
 
     first_space = skip_space
-    write_space_using_setting(first_space, @spaces_after_lambda_arrow)
+    write_space_using_setting(first_space, :one)
 
     if empty_params?(params)
       if current_token_kind == :on_lparen
@@ -2469,9 +2471,9 @@ class Rufo::Formatter
       if current_token_line == closing_brace_token[0][0]
         consume_token :on_tlambeg
 
-        consume_space unless !space? && @spaces_around_block_brace == :dynamic
+        consume_space
         visit_exps body, with_lines: false
-        consume_space unless !space? && @spaces_around_block_brace == :dynamic
+        consume_space
 
         consume_token :on_rbrace
         return
@@ -2517,7 +2519,7 @@ class Rufo::Formatter
     has_space = space?
 
     if has_space
-      consume_space(want_preserve_whitespace: @spaces_in_commands == :dynamic)
+      consume_space
     else
       skip_space_or_newline
     end
@@ -2567,34 +2569,15 @@ class Rufo::Formatter
     first_space = skip_space
 
     if inside_hash
-      case @spaces_inside_hash_brace
-      when :never
-        needs_final_space = false
-      when :always
-        needs_final_space = true
-      end
+      needs_final_space = false
     end
 
     if inside_array
-      case @spaces_inside_array_bracket
-      when :never
-        needs_final_space = false
-      when :always
-        needs_final_space = true
-      end
+      needs_final_space = false
     end
 
     if newline? || comment?
       needs_final_space = false
-    elsif needs_final_space
-      if inside_hash && first_space && @spaces_inside_hash_brace == :dynamic
-        write first_space[2]
-      elsif inside_array && first_space && @spaces_inside_array_bracket == :dynamic
-        write first_space[2]
-      else
-        consume_space
-      end
-      base_column = @column
     end
 
     # If there's a newline right at the beginning,
@@ -2614,13 +2597,11 @@ class Rufo::Formatter
     end
 
     wrote_comma = false
-    last_has_comma = false
     first_space = nil
 
     elements.each_with_index do |elem, i|
       is_last = last?(i, elements)
       wrote_comma = false
-      last_has_comma = false
 
       if needs_trailing_comma
         indent(needed_indent) { visit elem }
@@ -2633,21 +2614,8 @@ class Rufo::Formatter
       first_space = skip_space_no_heredoc_check
       wrote_comma = check_heredocs_in_literal_elements(is_last, needs_trailing_comma, wrote_comma)
 
-      if is_last && !comma? && !wrote_comma && !needs_trailing_comma && !comment?
-        if (inside_hash && @spaces_inside_hash_brace == :dynamic) ||
-           (inside_array && @spaces_inside_array_bracket == :dynamic)
-          if first_space
-            write first_space[2]
-          else
-            needs_final_space = false
-          end
-        end
-      end
-
       next unless comma?
 
-      last_has_comma = true
-
       unless is_last
         write ","
         wrote_comma = true
@@ -2669,22 +2637,13 @@ class Rufo::Formatter
             write_indent
           end
         end
-      elsif !is_last && first_space && @spaces_after_comma == :dynamic
-        write_space first_space[2]
-      elsif @spaces_after_comma == :one
+      else
         write_space unless is_last
       end
     end
 
     if needs_trailing_comma
-      case @trailing_commas
-      when :always
-        write "," unless wrote_comma
-      when :never
-        # Nothing
-      when :dynamic
-        write "," if last_has_comma && !wrote_comma
-      end
+      write "," unless wrote_comma || !trailing_commas
 
       consume_end_of_line(first_space: first_space)
       write_indent
@@ -2705,7 +2664,7 @@ class Rufo::Formatter
       # foo([
       #       2,
       #     ])
-      @literal_indents << [base_line, @line, token_column + @indent_size - needed_indent]
+      @literal_indents << [base_line, @line, token_column + INDENT_SIZE - needed_indent]
     elsif call_info && call_info[0] == current_token_column
       # If the closing literal position matches the column where
       # the call started, we want to preserve it like that
@@ -2822,16 +2781,13 @@ class Rufo::Formatter
     # [:when, conds, body, next_exp]
     _, conds, body, next_exp = node
 
-    preserve_whitespace = @spaces_around_when == :dynamic && !@align_case_when
-
     consume_keyword "when"
-    consume_space(want_preserve_whitespace: preserve_whitespace)
+    consume_space
 
     space_after_when = nil
 
     indent(@column) do
       visit_comma_separated_list conds
-      space_after_when = current_token if space? && preserve_whitespace
       skip_space
     end
 
@@ -2840,7 +2796,6 @@ class Rufo::Formatter
     if then_keyword
       next_token
 
-      space_after_then = current_token if space? && preserve_whitespace
       skip_space
 
       info = track_case_when
@@ -2852,11 +2807,7 @@ class Rufo::Formatter
         # Cancel tracking of `case when ... then` on a nelwine.
         @case_when_positions.pop
       else
-        if space_after_when
-          write_space space_after_when[2]
-        else
-          write_space
-        end
+        write_space
 
         write "then"
 
@@ -2877,11 +2828,7 @@ class Rufo::Formatter
           info[-1] = offset
         end
 
-        if space_after_then
-          write_space space_after_then[2]
-        else
-          write_space
-        end
+        write_space
       end
     elsif semicolon?
       skip_semicolons
@@ -2918,10 +2865,10 @@ class Rufo::Formatter
 
           indent_body next_exp[1]
         else
-          if @align_case_when
+          if align_case_when
             write_space
           else
-            write_space_using_setting(first_space, @spaces_around_when)
+            write_space_using_setting(first_space, :one)
           end
           visit_exps next_exp[1]
         end
@@ -2942,33 +2889,13 @@ class Rufo::Formatter
     end
   end
 
-  def consume_one_dynamic_space(setting, force_one: false)
-    if setting == :one || force_one
-      consume_space
-    else
-      if space?
-        consume_space(want_preserve_whitespace: true)
-      elsif newline?
-        next_token
-        if space?
-          write_space current_token[2]
-        end
-        skip_space_or_newline
-      else
-        skip_space_or_newline
-      end
-    end
-  end
-
-  def consume_one_dynamic_space_or_newline(setting)
+  def consume_space_or_newline
     first_space = skip_space
     if newline? || comment?
       consume_end_of_line
       write_indent(next_indent)
-    elsif first_space && setting == :dynamic
-      write_space first_space[2]
     else
-      consume_space if setting == :one
+      consume_space
     end
   end
 
@@ -3028,8 +2955,11 @@ class Rufo::Formatter
 
         write_indent if found_comment
         if current_token_value.end_with?("\n")
+          write_space
           write current_token_value.rstrip
-          write_line
+          write "\n"
+          write_indent(next_indent)
+          @column = next_indent
         else
           write current_token_value
         end
@@ -3201,7 +3131,7 @@ class Rufo::Formatter
             # so append a space if needed (for example after an expression)
             unless at_prefix
               # Preserve whitespace before comment unless we need to align them
-              if last_space && !@align_comments
+              if last_space
                 write last_space[2]
               else
                 write_space
@@ -3312,13 +3242,13 @@ class Rufo::Formatter
       yield
       @indent = old_indent
     else
-      @indent += @indent_size
+      @indent += INDENT_SIZE
       yield
-      @indent -= @indent_size
+      @indent -= INDENT_SIZE
     end
   end
 
-  def indent_body(exps, force_multiline: false, want_multiline: false)
+  def indent_body(exps, force_multiline: false)
     first_space = skip_space
 
     has_semicolon = semicolon?
@@ -3334,7 +3264,7 @@ class Rufo::Formatter
       if has_semicolon
         write "; "
       else
-        write_space_using_setting(first_space, @spaces_in_inline_expressions)
+        write_space_using_setting(first_space, :one)
       end
       return
     end
@@ -3359,28 +3289,23 @@ class Rufo::Formatter
       if has_then
         write " then "
       elsif has_do
-        write_space_using_setting(first_space, @spaces_in_inline_expressions, at_least_one: true)
+        write_space_using_setting(first_space, :one, at_least_one: true)
         write "do"
-        write_space_using_setting(second_space, @spaces_in_inline_expressions, at_least_one: true)
+        write_space_using_setting(second_space, :one, at_least_one: true)
       elsif has_semicolon
         write "; "
       else
-        write_space_using_setting(first_space, @spaces_in_inline_expressions, at_least_one: true)
+        write_space_using_setting(first_space, :one, at_least_one: true)
       end
       visit_exps exps, with_indent: false, with_lines: false
 
-      first_space = skip_space
-      if first_space && @spaces_in_inline_expressions == :dynamic &&
-         !(semicolon? || newline? || comment?)
-        write_space first_space[2]
-      else
-        consume_space
-      end
+      consume_space
+
       return
     end
 
     indent do
-      consume_end_of_line(want_multiline: want_multiline)
+      consume_end_of_line(want_multiline: false)
     end
 
     if keyword?("then")
@@ -3394,7 +3319,7 @@ class Rufo::Formatter
       skip_space_or_newline
     else
       indent do
-        visit_exps exps, with_indent: true, want_trailing_multiline: want_multiline
+        visit_exps exps, with_indent: true
       end
       write_line unless @last_was_newline
     end
@@ -3413,6 +3338,7 @@ class Rufo::Formatter
   def write(value)
     @output << value
     @last_was_newline = false
+    @last_was_heredoc = false
     @column += value.size
   end
 
@@ -3453,7 +3379,7 @@ class Rufo::Formatter
     @column += indent
   end
 
-  def indent_after_space(node, sticky: false, want_space: true, first_space: nil, needed_indent: next_indent, token_column: nil, base_column: nil, preserve_whitespace:)
+  def indent_after_space(node, sticky: false, want_space: true, first_space: nil, needed_indent: next_indent, token_column: nil, base_column: nil)
     first_space = current_token if space?
     skip_space
 
@@ -3477,11 +3403,7 @@ class Rufo::Formatter
       end
     else
       if want_space
-        if first_space && preserve_whitespace
-          write_space first_space[2]
-        else
-          write_space
-        end
+        write_space
       end
       if sticky
         indent(@column) do
@@ -3494,7 +3416,7 @@ class Rufo::Formatter
   end
 
   def next_indent
-    @indent + @indent_size
+    @indent + INDENT_SIZE
   end
 
   def check(kind)
@@ -3558,64 +3480,6 @@ class Rufo::Formatter
     node.size == 1 && node[0].size == 1 && node[0][0] == :void_stmt
   end
 
-  def adjust_visibility_indent(node, base_column)
-    return if @visibility_indent == :align
-
-    case node[1]
-    when "private", "protected", "public"
-      # OK
-    else
-      return
-    end
-
-    i = @tokens.size - 1
-
-    # First, skip spaces until a newline or comment
-    while i >= 0
-      token = @tokens[i]
-      case token[1]
-      when :on_sp
-        i -= 1
-        next
-      when :on_nl, :on_ignored_nl, :on_comment
-        i -= 1
-        break
-      else
-        return
-      end
-    end
-
-    if @visibility_indent_in_action[@current_type]
-      last_newline_index = @output.rindex("\n")
-      if last_newline_index
-        # Remove extra indent if we are indenting inside private/protected/public
-        # and we just found another one.
-        @output = "#{@output[0..last_newline_index]}#{@output[last_newline_index + 1 + @indent_size..-1]}".dup
-        @indent -= @indent_size
-        @visibility_indent_in_action.delete @current_type
-      end
-    end
-
-    # Now we skip all spaces and newlines
-    while i >= 0
-      token = @tokens[i]
-      case token[1]
-      when :on_sp, :on_nl, :on_ignored_nl
-        i -= 1
-        next
-      else
-        break
-      end
-    end
-
-    return if i < 0
-
-    if @visibility_indent == :indent || base_column + @indent_size == @tokens[i][0][1]
-      @indent += @indent_size
-      @visibility_indent_in_action[@current_type] = true
-    end
-  end
-
   def find_closing_brace_token
     count = 0
     i = @tokens.size - 1
@@ -3739,7 +3603,7 @@ class Rufo::Formatter
         next if @unmodifiable_string_lines[line]
 
         current_line = lines[line]
-        current_line = current_line[diff..-1]
+        current_line = current_line[diff..-1] if diff >= 0
 
         # It can happen that this line didn't need an indent because
         # it simply had a newline
@@ -3772,18 +3636,6 @@ class Rufo::Formatter
     @output = lines.join
   end
 
-  def do_align_comments
-    do_align @comments_positions, :comment
-  end
-
-  def do_align_assignments
-    do_align @assignments_positions, :assign
-  end
-
-  def do_align_hash_keys
-    do_align @hash_keys_positions, :hash_key
-  end
-
   def do_align_case_when
     do_align @case_when_positions, :case
   end
@@ -3799,16 +3651,6 @@ class Rufo::Formatter
     chunks.each do |elements|
       next if elements.size == 1
 
-      if scope == :hash_key
-        # Don't indent successive hash keys if any of them is in turn a hash
-        # or array literal that is formatted in separate lines.
-        has_brace_newline = elements.any? do |(l, c)|
-          line_end = lines[l][c..-1]
-          line_end.start_with?("=> {\n", "=> [\n", "=> [ #", "=> { #", "[\n", "{\n", "[ #", "{ #")
-        end
-        next if has_brace_newline
-      end
-
       max_column = elements.map { |l, c| c }.max
 
       elements.each do |(line, column, _, _, offset)|
@@ -3867,6 +3709,12 @@ class Rufo::Formatter
     end
   end
 
+  def broken_ripper_version?
+    version, teeny = RUBY_VERSION[0..2], RUBY_VERSION[4..4].to_i
+    (version == "2.3" && teeny < 5) ||
+      (version == "2.4" && teeny < 2)
+  end
+
   def remove_lines_before_inline_declarations
     return if @inline_declarations.empty?