RuboCop vs Rufo

Messy indentation and inconsistent spacing are annoying, but style violations and subtle bugs are much worse. Ruby has tools for both problems, and while RuboCop and Rufo are often mentioned in the same breath, they actually solve very different challenges.

RuboCop is much more than a formatter. It’s a linter and static analysis tool that inspects your code for style violations, complexity issues, and even potential bugs. While it can automatically fix many problems, its real strength is enforcing coding standards and catching issues before they turn into real errors.

Rufo, by contrast, doesn’t care about style guides or code quality. Its only job is to make your code look tidy—handling indentation, spacing, and line breaks. It won’t judge your approach or suggest improvements, but it will guarantee your code is consistently formatted every single time.

So when deciding between them, the real question isn’t “which formatter is better?” but rather “what problem am I trying to solve?” Do you need a tool that enforces style rules and helps prevent bugs, or one that simply keeps your files neat and uniform?

What is RuboCop?

RuboCop is a Ruby static code analyzer that enforces style guidelines and detects potential problems. Created to bring consistency to Ruby codebases, RuboCop checks your code against hundreds of rules covering everything from indentation to method complexity.

The tool includes three types of checks: style rules (like preferred quote styles), performance suggestions (like using more efficient methods), and security warnings (like potential SQL injection risks). When RuboCop finds violations, it can often fix them automatically.

RuboCop works as both a linter and formatter. It not only formats your code but also suggests improvements that could make it more maintainable, faster, or safer.

What is Rufo?

Rufo is a Ruby formatter that focuses exclusively on making code look consistent. Created by Ary Borenszweig as a simpler alternative to complex linting tools, Rufo takes your code and applies consistent formatting without changing the logic or suggesting improvements.

The tool follows a specific set of formatting rules: where to put spaces, how to indent blocks, when to break lines. It doesn't care about your variable names, method length, or coding patterns - it just makes everything look uniform.

Rufo works as a pure formatter. It takes whatever you write and makes it look clean, leaving all the code quality decisions up to you.

RuboCop vs Rufo: quick comparison

Configuration and setup

That difference between "comprehensive analysis" and "just formatting" became obvious the moment I tried to set up both tools. RuboCop greeted me with decisions about hundreds of rules, while Rufo asked me to choose between single and double quotes.

RuboCop requires thoughtful configuration to work well with your team's preferences:

# .rubocop.yml
AllCops:
  TargetRubyVersion: 3.0
  Exclude:
    - 'db/**/*'
    - 'vendor/**/*'

Layout/LineLength:
  Max: 120

Style/Documentation:
  Enabled: false

Style/FrozenStringLiteralComment:
  Enabled: true

Metrics/MethodLength:
  Max: 15
  Exclude:
    - 'spec/**/*'

RuboCop's configuration can become quite complex. Teams often spend time debating which rules to enable, what limits to set, and which files to exclude. The configuration file can grow to hundreds of lines as you customize rules for your specific needs.

Rufo keeps configuration minimal:

# .rufo
quote_style :double
trailing_commas [:multiline]

Rufo's configuration covers just the basic formatting preferences. You choose quote styles, comma placement, and a few other formatting details, then let Rufo handle the rest automatically.

Running the tools

After spending an hour configuring RuboCop's 80-line config file compared to Rufo's 3-line setup, I wanted to see how this complexity difference played out when actually using the tools.

RuboCop provides detailed feedback about what it finds:

$ rubocop app/models/user.rb
Inspecting 1 file
C

Offenses:

app/models/user.rb:5:1: C: Style/Documentation: Missing top-level class documentation comment.
class User < ApplicationRecord
^^^^^

app/models/user.rb:12:81: C: Layout/LineLength: Line is too long. [91/80]
    validates :email, presence: true, uniqueness: true, format: { with: VALID_EMAIL_REGEX }
                                                                                 ^^^^^^^^^^^

app/models/user.rb:18:5: C: Style/GuardClause: Use a guard clause instead of wrapping the code inside a conditional expression.
    if user.present?
    ^^^^^^^^^^^^^^^^

1 file inspected, 3 offenses detected, 2 offenses autocorrectable

RuboCop tells you exactly what's wrong, where it's located, and whether it can fix the problem automatically. You can run rubocop -a to apply automatic fixes, or address each issue manually.

Rufo works silently and focuses only on formatting:

$ rufo app/models/user.rb
$ echo $?
0

Rufo formats your file and exits quietly. There's no output unless something goes wrong. You can see the changes in your git diff, but Rufo doesn't explain what it changed or why.

Code transformation examples

The contrast between RuboCop's detailed violation reports and Rufo's silent operation made me curious about what each tool actually did to the same messy code. So I took a poorly formatted method and ran both tools on it.

RuboCop analyzes and suggests improvements:

# Before
def process_user(user_data)
  if user_data != nil
    user = User.new
    user.name = user_data['name']
    user.email = user_data['email']
    if user.save
      send_welcome_email(user)
      return user
    else
      return nil
    end
  end

end

# After RuboCop auto-fix
def process_user(user_data)
  return if user_data.nil?

  user = User.new
  user.name = user_data['name']
  user.email = user_data['email']
  if user.save
    send_welcome_email(user)
    user
  end
end

RuboCop transformed the logic structure: it converted the nil check to a guard clause, removed unnecessary return statements, and improved the overall flow. These changes make the code more readable and follow Ruby conventions.

Rufo only changes formatting:

# Before
def process_user(user_data)
if user_data != nil
user = User.new
user.name = user_data['name']
user.email=user_data['email']
if user.save
send_welcome_email(user)
return user
else
return nil
end
end
end

# After Rufo
def process_user(user_data)
  if user_data != nil
    user = User.new
    user.name = user_data['name']
    user.email = user_data['email']
    if user.save
      send_welcome_email(user)
      return user
    else
      return nil
    end
  end
end

Rufo fixed the indentation and spacing but left the logic exactly as written. The nil check, return statements, and nested structure remain unchanged because Rufo doesn't make judgments about code quality.

Team workflow integration

Seeing RuboCop restructure that method logic while Rufo only fixed indentation made me realize these tools would create very different team dynamics. One would generate discussions about code quality, the other would just make everything look neat.

RuboCop requires team coordination to work smoothly:

# Git pre-commit hook
#!/bin/sh
bundle exec rubocop --only-recognized-file-types

if [ $? -ne 0 ]; then
  echo "RuboCop violations found. Fix them before committing."
  exit 1
fi

Teams using RuboCop need to agree on which rules to follow and how strictly to enforce them. New team members need time to learn the rules, and pull requests often include formatting changes alongside feature changes.

Rufo integrates seamlessly without requiring team discussions:

# Git pre-commit hook
#!/bin/sh
bundle exec rufo --check .

if [ $? -ne 0 ]; then
  echo "Code needs formatting. Run 'rufo .' to fix."
  exit 1
fi

Rufo works immediately for any team because there are no subjective rules to debate. Everyone just runs the formatter, and all code looks consistent automatically.

Editor and IDE integration

The team coordination difference I discovered - RuboCop requiring rule discussions while Rufo needing none - made me wonder how this translated to the daily editing experience where developers actually write code.

RuboCop integration provides real-time feedback:

// VS Code settings.json
{
  "ruby.rubocop.executePath": "/usr/local/bin/",
  "ruby.rubocop.onSave": true,
  "ruby.format": "rubocop"
}

Your editor shows RuboCop violations as you type, with underlines and hover tooltips explaining each issue. You can fix problems immediately or let the editor auto-format on save.

Rufo integration focuses on automatic formatting:

// VS Code settings.json
{
  "ruby.format": "rufo",
  "editor.formatOnSave": true
}

Rufo runs invisibly in the background. Your code gets formatted automatically when you save, with no interruptions or decision-making required.

Performance on large codebases

The editor integration showed me that RuboCop analyzes code in real-time while Rufo just formats it. This made me curious about how that analysis overhead would scale when I ran both tools on our entire Rails application.

RuboCop takes time to analyze everything:

$ time bundle exec rubocop
Inspecting 847 files
.............................C..............................

847 files inspected, 23 offenses detected

real    0m45.123s
user    0m42.456s
sys     0m2.667s

RuboCop needs to analyze each file thoroughly, checking hundreds of rules against thousands of lines of code. The analysis is comprehensive but slow, especially on first runs.

Rufo processes the same codebase much faster:

$ time bundle exec rufo .

real    0m8.234s
user    0m7.123s
sys     0m1.111s

Rufo only needs to parse and reformat code, which is much faster than the deep analysis RuboCop performs. Large codebases see significant time savings.

Handling edge cases and conflicts

That 45-second RuboCop run versus 8-second Rufo run got me wondering: was RuboCop's analysis actually catching problems that Rufo missed, or was it just slower? I decided to test both tools on some tricky Ruby code to find out.

RuboCop sometimes struggles with dynamic code:

# RuboCop might flag this as too complex
ATTRIBUTES.each do |attr|
  define_method "#{attr}=" do |value|
    instance_variable_set("@#{attr}", value)
    notify_observers(attr, value)
  end
end

# RuboCop prefers explicit methods
def name=(value)
  @name = value
  notify_observers(:name, value)
end

RuboCop's complexity metrics don't always account for metaprogramming patterns that are common in Rails applications. You might need to disable rules for specific files or methods.

Rufo handles any valid Ruby syntax consistently:

# Rufo formats this cleanly regardless of complexity
ATTRIBUTES.each do |attr|
  define_method "#{attr}=" do |value|
    instance_variable_set("@#{attr}", value)
    notify_observers(attr, value)
  end
end

Since Rufo doesn't judge code quality, it formats any valid Ruby syntax without complaints or special configuration.

Final thoughts

Testing that combination approach taught me something important: the tools aren't trying to solve the same problem, so treating them like competitors misses the point entirely.

RuboCop solved my code quality problem. When I wanted to catch potential bugs, enforce consistent patterns, and help team members write better Ruby, RuboCop's comprehensive analysis made a real difference in our codebase quality.

Rufo solved my formatting problem. When I just wanted consistent indentation and spacing without spending time on style debates, Rufo handled all formatting decisions automatically and invisibly.

The breakthrough came when I stopped asking "which tool is better?" and started asking "what problem am I trying to solve?" RuboCop for analysis and improvement. Rufo for formatting and consistency. Both have clear, different purposes.

Got an article suggestion? Let us know

Next article

Ruby on Rails vs Fastify

Learn how Ruby on Rails speeds up MVPs with built-in tools, while Fastify offers flexibility and control for custom, high-performance apps.

→

This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.