Ruby Style Guide

https://rubystyle.guide/
Admin
The Ruby Style Guide provides a comprehensive set of conventions and best practices for writing...
Tokens:48,631
Snippets:603
Trust Score:8.9
Update:1 day ago
Show doc for...
Tokens:
Raw
### Use when x then for one-line cases

Source: https://rubystyle.guide/

Shows bad and good examples of one-line case branches. The bad example uses multi-line when clauses, while the good example uses then for one-line branches.

```ruby
# bad
case year
when 1850..1889
  'Blues'
when 1890..1909
  'Ragtime'
when 1910..1929
  'New Orleans Jazz'
when 1930..1939
  'Swing'
when 1940..1950
  'Bebop'
else
  'Jazz'
end

# good
case year
when 1850..1889 then 'Blues'
when 1890..1909 then 'Ragtime'
when 1910..1929 then 'New Orleans Jazz'
when 1930..1939 then 'Swing'
when 1940..1950 then 'Bebop'
else                  'Jazz'
end
```

--------------------------------

### Use implicit begin blocks

Source: https://rubystyle.guide/

Prefer implicit begin blocks where possible. The bad example uses an explicit begin, the good example uses the method body as the begin block.

```ruby
# bad
def foo
  begin
    # main logic goes here
  rescue
    # failure handling goes here
  end
end

# good
def foo
  # main logic goes here
rescue
  # failure handling goes here
end
```

--------------------------------

### Avoid then in multi-line if/unless/when/in

Source: https://rubystyle.guide/

Shows bad and good examples of using then in multi-line if, case/when, and case/in expressions. The bad examples use then, while the good examples omit it.

```ruby
# bad
if some_condition then
  # body omitted
end

# bad
case foo
when bar then
  # body omitted
end

# bad
case expression
in pattern then
  # body omitted
end

# good
if some_condition
  # body omitted
end

# good
case foo
when bar
  # body omitted
end

# good
case expression
in pattern
  # body omitted
end
```

--------------------------------

### Method arguments alignment examples

Source: https://rubystyle.guide/

Shows four variations of aligning method arguments that span multiple lines: a starting point with a long line, a bad double-indent style, a good aligned style, and a good normal-indent style. The good styles are acceptable when line-length constraints apply.

```ruby
# starting point (line is too long)
def send_mail(source)
  Mailer.deliver(to: 'bob@example.com', from: 'us@example.com', subject: 'Important message', body: source.text)
end

# bad (double indent)
def send_mail(source)
  Mailer.deliver(
      to: 'bob@example.com',
      from: 'us@example.com',
      subject: 'Important message',
      body: source.text)
end

# good
def send_mail(source)
  Mailer.deliver(to: 'bob@example.com',
                 from: 'us@example.com',
                 subject: 'Important message',
                 body: source.text)
end

# good (normal indent)
def send_mail(source)
  Mailer.deliver(
    to: 'bob@example.com',
    from: 'us@example.com',
    subject: 'Important message',
    body: source.text
  )
end
```

--------------------------------

### Avoid tap in production code

Source: https://rubystyle.guide/

Shows a bad example using tap and a good example without it. The good example is simpler and more efficient.

```ruby
# bad
Config.new(hash, path).tap do |config|
  config.check if check
end

# good
config = Config.new(hash, path)
config.check if check
config
```

--------------------------------

### Avoid Needless Metaprogramming: define_method vs attr_reader

Source: https://rubystyle.guide/

Shows a bad example using define_method to create getters and a good example using attr_reader. Use attr_reader for simple attribute access.

```ruby
# bad
class Person
  %i[name age email].each do |attr|
    define_method(attr) { instance_variable_get("@#{attr}") }
  end
end

# good
class Person
  attr_reader :name, :age, :email
end
```

--------------------------------

### Use if/case as expressions returning results

Source: https://rubystyle.guide/

Shows bad and good examples of leveraging the fact that if and case are expressions that return a result. The good example assigns the result directly from the if expression.

```ruby
# bad
if condition
  result = x
else
  result = y
end

# good
result =
  if condition
    x
  else
    y
  end
```

--------------------------------

### Two or More Empty Lines

Source: https://rubystyle.guide/

Shows bad and good examples of avoiding multiple consecutive empty lines. The bad example has two empty lines in a row.

```ruby
# bad - It has two empty lines.
some_method


some_method

# good
some_method

some_method
```

--------------------------------

### Code in a functional way, avoiding mutation when that makes sense

Source: https://rubystyle.guide/

Shows bad examples using each with mutation and good examples using map, reduce, and each_with_object.

```ruby
a = []; [1, 2, 3].each { |i| a << i * 2 }   # bad
a = [1, 2, 3].map { |i| i * 2 }             # good

a = {}; [1, 2, 3].each { |i| a[i] = i * 17 }                # bad
a = [1, 2, 3].reduce({}) { |h, i| h[i] = i * 17; h }        # good
a = [1, 2, 3].each_with_object({}) { |i, h| h[i] = i * 17 } # good
```

--------------------------------

### Avoid BEGIN blocks

Source: https://rubystyle.guide/

Shows bad and good examples for avoiding the use of BEGIN blocks.

```ruby
# bad
puts 'Hello!'
BEGIN { puts 'Initializing...' }

# good
puts 'Initializing...'
puts 'Hello!'

```

--------------------------------

### Avoid shadowing methods

Source: https://rubystyle.guide/

Shows a class with examples of avoiding shadowing methods with local variables unless they are equivalent. Includes ok, bad, and good examples.

```ruby
class Foo
  attr_accessor :options

  # ok
  def initialize(options)
    self.options = options
    # both options and self.options are equivalent here
  end

  # bad
  def do_something(options = {})
    unless options[:when] == :later
      output(self.options[:message])
    end
  end

  # good
  def do_something(params = {})
    unless params[:when] == :later
      output(options[:message])
    end
  end
end

```

--------------------------------

### Prefer bitwise predicate methods

Source: https://rubystyle.guide/

Shows bad and good examples. Use anybits?, allbits?, nobits? instead of direct bitwise comparisons.

```Ruby
# bad - checks any set bits
(variable & flags).positive?

# good
variable.anybits?(flags)

# bad - checks all set bits
(variable & flags) == flags

# good
variable.allbits?(flags)

# bad - checks no set bits
(variable & flags).zero?
(variable & flags) == 0

# good
variable.nobits?(flags)
```

--------------------------------

### other Parameter Naming Example

Source: https://rubystyle.guide/

Shows good and bad examples of naming parameters for binary operators. Use 'other' for operators with symmetrical semantics (e.g., +, -, *, ==), but not for non-symmetrical operators like << and * when the semantics are not symmetrical.

```ruby
# good
def +(other)
  # body omitted
end

# bad
def <<(other)
  @internal << other
end

# good
def <<(item)
  @internal << item
end

# bad
# Returns some string multiplied `other` times
def *(other)
  # body omitted
end

# good
# Returns some string multiplied `num` times
def *(num)
  # body omitted
end
```

--------------------------------

### Use ranges or between? for comparisons

Source: https://rubystyle.guide/

Shows bad and good examples. Use ranges or Comparable#between? instead of complex comparison logic.

```Ruby
# bad
do_something if x >= 1000 && x <= 2000

# good
do_something if (1000..2000).include?(x)

# good
do_something if x.between?(1000, 2000)
```

--------------------------------

### Prefer next in loops over conditionals

Source: https://rubystyle.guide/

Shows a bad example using an if block inside a loop and a good example using next to skip items.

```ruby
# bad
[0, 1, 2, 3].each do |item|
  if item > 1
    puts item
  end
end

# good
[0, 1, 2, 3].each do |item|
  next unless item > 1
  puts item
end
```

--------------------------------

### Avoid more than three levels of block nesting

Source: https://rubystyle.guide/

Shows a bad example with three nested each blocks and a good example that extracts nested logic into separate methods.

```ruby
# bad
def process(items)
  items.each do |item|
    item.widgets.each do |widget|
      widget.parts.each do |part|
        part.update!
      end
    end
  end
end

# good
def process(items)
  items.each do |item|
    process_widgets(item.widgets)
  end
end

def process_widgets(widgets)
  widgets.each do |widget|
    widget.parts.each(&:update!)
  end
end
```

--------------------------------

### Put condition on same line as if/unless

Source: https://rubystyle.guide/

Shows bad and good examples of placing the condition in a multi-line conditional. The bad example puts the condition on a separate line, while the good example puts it on the same line as the if.

```ruby
# bad
if
  some_condition
  do_something
  do_something_else
end

# good
if some_condition
  do_something
  do_something_else
end
```

--------------------------------

### proc vs Proc.new

Source: https://rubystyle.guide/

Prefer proc over Proc.new. The example shows bad and good usages.

```ruby
# bad
p = Proc.new { |n| puts n }

# good
p = proc { |n| puts n }
```

--------------------------------

### Factory method example

Source: https://rubystyle.guide/

Shows a class method `self.create` as a factory method to provide an additional way to create instances of a class.

```ruby
class Person
  def self.create(options_hash)
    # body omitted
  end
end
```

--------------------------------

### No Monkey Patching: Use Refinements

Source: https://rubystyle.guide/

Shows a bad example of monkey patching String and a good example using a refinement. Use refinements to avoid modifying core classes globally.

```ruby
# bad
class String
  def to_hierarchical_date
    split('-').map(&:to_i)
  end
end

# good - use refinements instead
module DateParsing
  refine String do
    def to_hierarchical_date
      split('-').map(&:to_i)
    end
  end
end
```

--------------------------------

### Avoid nested conditionals; use guard clause

Source: https://rubystyle.guide/

Shows a bad example with nested conditionals and a good example using a guard clause to return early.

```ruby
# bad
def compute_thing(thing)
  if thing[:foo]
    update_with_bar(thing[:foo])
    if thing[:foo][:bar]
      partial_compute(thing)
    else
      re_compute(thing)
    end
  end
end

# good
def compute_thing(thing)
  return unless thing[:foo]
  update_with_bar(thing[:foo])
  return re_compute(thing) unless thing[:foo][:bar]
  partial_compute(thing)
end
```

--------------------------------

### No Mutable Keys: Avoid mutable objects as hash keys

Source: https://rubystyle.guide/

Shows bad and good examples of hash keys. The good examples use symbols or frozen strings.

```ruby
# bad
hash = { 'name' => 'John' }

# good
hash = { name: 'John' }

# good - frozen string key when symbols won't do
hash = { 'name'.freeze => 'John' }
```

--------------------------------

### Do not mutate parameters unless that is the purpose of the method

Source: https://rubystyle.guide/

Contrasts a bad example that mutates the users array with reject! and a good example using non-mutating reject.

```ruby
# bad
def clean(users)
  users.reject!(&:disabled?)
  users
end

# good
def clean(users)
  users.reject(&:disabled?)
end
```

--------------------------------

### Use require_relative for internal dependencies

Source: https://rubystyle.guide/

Shows bad and good examples. Use require_relative for internal dependencies and require for external ones.

```Ruby
# bad
require 'set'
require 'my_gem/spec/helper'
require 'my_gem/lib/something'

# good
require 'set'
require_relative 'helper'
require_relative '../lib/something'
```

--------------------------------

### Avoid cryptic Perlisms

Source: https://rubystyle.guide/

Shows bad and good examples. Use human-friendly aliases from the English library instead of Perl-style special variables.

```Ruby
# bad
$:.unshift File.dirname(__FILE__)

# good
$LOAD_PATH.unshift File.dirname(__FILE__)
```

```Ruby
# bad
print $', $$

# good
require 'English'
print $POSTMATCH, $PID
```

--------------------------------

### Private Global Methods: Add to Kernel and Make Private

Source: https://rubystyle.guide/

If you really need 'global' methods, add them to Kernel and make them private. The bad example defines a global method directly, while the good example wraps it in a module Kernel with private.

```ruby
# bad
def global_helper
  # ...
end

# good
module Kernel
  private

  def global_helper
    # ...
  end
end
```

--------------------------------

### %i: Prefer %i for arrays of symbols

Source: https://rubystyle.guide/

Shows bad and good ways to create an array of symbols. The good example uses %i with brackets.

```ruby
# bad
STATES = [:draft, :open, :closed]

# good
STATES = %i[draft open closed]
```

--------------------------------

### Prefer until over while for negative conditions

Source: https://rubystyle.guide/

Shows bad and good examples for using until instead of while for negative conditions.

```ruby
# bad
do_something while !some_condition

# good
do_something until some_condition

```

--------------------------------

### Don't Abuse gsub

Source: https://rubystyle.guide/

Use specialized methods like sub and tr instead of gsub when possible. The bad example uses gsub, the good example uses sub and tr.

```ruby
url = 'http://example.com'
str = 'lisp-case-rules'

# bad
url.gsub('http://', 'https://')
str.gsub('-', '_')

# good
url.sub('http://', 'https://')
str.tr('-', '_')
```

--------------------------------

### Plain Text Search in Ruby

Source: https://rubystyle.guide/

Use string indexing instead of a regular expression for plain text search. The example shows a bad approach using =~ and a good approach using string['example'].

```ruby
foo = 'I am an example string'

# bad - using a regular expression is an overkill here
foo =~ /example/

# good
foo['example']
```

--------------------------------

### Values Swapping - Bad and Good Examples

Source: https://rubystyle.guide/

Shows the discouraged temporary variable approach and the preferred parallel assignment for swapping two values.

```Ruby
# bad
tmp = x
x = y
y = tmp

# good
x, y = y, x
```

--------------------------------

### Avoid multi-line while do

Source: https://rubystyle.guide/

Shows bad and good examples for not using while/until condition do for multi-line while/until.

```ruby
# bad
while x > 5 do
  # body omitted
end

until x > 5 do
  # body omitted
end

# good
while x > 5
  # body omitted
end

until x > 5
  # body omitted
end

```

--------------------------------

### Avoid unless with else

Source: https://rubystyle.guide/

Shows bad and good examples for using if/else instead of unless/else. Rewrite with the positive case first.

```ruby
# bad
unless success?
  puts 'failure'
else
  puts 'success'
end

# good
if success?
  puts 'success'
else
  puts 'failure'
end

```

--------------------------------

### Omit the .rb extension for require and require_relative

Source: https://rubystyle.guide/

Shows bad examples with .rb extension and good examples without it, including .so files. Note that omitting the extension causes Ruby to try adding .rb, .so, etc., and raises LoadError if not found.

```ruby
# bad
require 'foo.rb'
require_relative '../foo.rb'

# good
require 'foo'
require 'foo.so'
require_relative '../foo'
require_relative '../foo.so'
```

--------------------------------

### sprintf

Source: https://rubystyle.guide/

Prefer sprintf and format over String#%. The example shows bad and good usages with positional and named arguments.

```ruby
# bad
'%d %d' % [20, 10]
# => '20 10'

# good
sprintf('%d %d', 20, 10)
# => '20 10'

# good
sprintf('%<first>d %<second>d', first: 20, second: 10)
# => '20 10'

format('%d %d', 20, 10)
# => '20 10'

# good
format('%<first>d %<second>d', first: 20, second: 10)
# => '20 10'
```

--------------------------------

### Consider using Struct.new

Source: https://rubystyle.guide/

Shows the good practice of defining a class with attr_accessor and initialize, and the better practice of using Struct.new.

```ruby
# good
class Person
  attr_accessor :first_name, :last_name

  def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
  end
end

# better
Person = Struct.new(:first_name, :last_name) do
end
```

--------------------------------

### Avoid DateTime unless historical calendar reform is needed

Source: https://rubystyle.guide/

Don't use DateTime unless you need to account for historical calendar reform. If you do, explicitly specify the start argument. The example shows bad and good usages for current time, modern dates, and historical dates.

```ruby
# bad - uses DateTime for current time
DateTime.now

# good - uses Time for current time
Time.now

# bad - uses DateTime for modern date
DateTime.iso8601('2016-06-29')

# good - uses Date for modern date
Date.iso8601('2016-06-29')

# good - uses DateTime with start argument for historical date
DateTime.iso8601('1751-04-23', Date::ENGLAND)

```

--------------------------------

### Parallel Assignment - Bad and Good Examples

Source: https://rubystyle.guide/

Shows discouraged parallel assignment for defining variables and acceptable uses: swapping variables, method returns, and splat operator. The good examples demonstrate when parallel assignment is allowed.

```Ruby
# bad
a, b, c, d = 'foo', 'bar', 'baz', 'foobar'

# good
a = 'foo'
b = 'bar'
c = 'baz'
d = 'foobar'

# good - swapping variable assignment
# Swapping variable assignment is a special case because it will allow you to
# swap the values that are assigned to each variable.
a = 'foo'
b = 'bar'

a, b = b, a
puts a # => 'bar'
puts b # => 'foo'

# good - method return
def multi_return
  [1, 2]
end

first, second = multi_return

# good - use with splat
first, *list = [1, 2, 3, 4] # first => 1, list => [2, 3, 4]

hello_array = *'Hello' # => ["Hello"]

a = *(1..3) # => [1, 2, 3]
```

--------------------------------

### Merging Keyword Arguments: Prefer Direct Arguments over merge

Source: https://rubystyle.guide/

When passing an existing hash as keyword arguments, add additional arguments directly rather than using merge. The bad example uses opts.merge(foo: true), while the good example passes **opts, foo: true.

```ruby
# bad
some_method(**opts.merge(foo: true))

# good
some_method(**opts, foo: true)
```

--------------------------------

### Prefer reverse_each over reverse.each

Source: https://rubystyle.guide/

Shows bad and good examples for iterating in reverse. Prefer reverse_each because some classes provide efficient implementations.

```ruby
# bad
array.reverse.each { ... }

# good
array.reverse_each { ... }
```

--------------------------------

### Unused Variables Prefix Example

Source: https://rubystyle.guide/

Shows bad and good examples of prefixing unused block parameters and local variables with an underscore. The Ruby interpreter and tools like RuboCop recognize this convention and suppress unused variable warnings.

```ruby
# bad
result = hash.map { |k, v| v + 1 }

def something(x)
  unused_var, used_var = something_else(x)
  # some code
end

# good
result = hash.map { |_k, v| v + 1 }

def something(x)
  _unused_var, used_var = something_else(x)
  # some code
end

# good
result = hash.map { |_, v| v + 1 }

def something(x)
  _, used_var = something_else(x)
  # some code
end
```

--------------------------------

### Arguments Forwarding: Use Ruby 2.7's ... Forwarding

Source: https://rubystyle.guide/

Use Ruby 2.7's arguments forwarding. The bad examples show explicit forwarding of *args, **kwargs, and &block, and note that using ... forwards the block as well, which can cause unexpected incompatible behavior. The good example uses ... to forward all arguments.

```ruby
# bad
def some_method(*args, &block)
  other_method(*args, &block)
end

# bad
def some_method(*args, **kwargs, &block)
  other_method(*args, **kwargs, &block)
end

# bad
# Please note that it can cause unexpected incompatible behavior
# because `...` forwards block also.
# https://github.com/rubocop/rubocop/issues/7549
def some_method(*args)
  other_method(*args)
end

# good
def some_method(...)
  other_method(...)
end
```

--------------------------------

### Literal Array and Hash: Prefer literal creation unless parameters needed

Source: https://rubystyle.guide/

Shows bad and good ways to create arrays and hashes. The good examples use literal syntax, and also show constructor calls with parameters.

```ruby
# bad
arr = Array.new
hash = Hash.new

# good
arr = []
arr = Array.new(10)
hash = {}
hash = Hash.new(0)
```

--------------------------------

### Avoid semicolon in when; use then

Source: https://rubystyle.guide/

Shows bad and good examples of using semicolons in when branches. The bad example uses semicolons, while the good example uses then.

```ruby
# bad
case year
when 1850..1889; 'Blues'
when 1890..1909; 'Ragtime'
else; 'Jazz'
end

# good
case year
when 1850..1889 then 'Blues'
when 1890..1909 then 'Ragtime'
else                  'Jazz'
end
```

--------------------------------

### Prefer map, find, select, reduce, include?, size over aliases

Source: https://rubystyle.guide/

Shows bad and good examples for Enumerable method names. Prefer map over collect, find over detect, select over find_all, reduce over inject, include? over member?, and size over length.

```ruby
# bad
items.collect { |item| item.name }
items.detect(&:active?)
items.find_all(&:valid?)
items.inject(0) { |sum, i| sum + i }
items.member?(value)
items.length

# good
items.map { |item| item.name }
items.find(&:active?)
items.select(&:valid?)
items.reduce(0) { |sum, i| sum + i }
items.include?(value)
items.size
```

--------------------------------

### Avoid semicolon in in; use then

Source: https://rubystyle.guide/

Shows bad and good examples of using semicolons in in pattern branches. The bad example uses a semicolon, while the good example uses then.

```ruby
# bad
case expression
in pattern; do_something
end

# good
case expression
in pattern then do_something
end
```

--------------------------------

### Use ! instead of not

Source: https://rubystyle.guide/

Shows bad and good examples of using the negation operator. The bad example uses not, which requires parentheses due to operator precedence, while the good example uses !.

```ruby
# bad - parentheses are required because of op precedence
x = (not something)

# good
x = !something
```

--------------------------------

### Reading from a file: use File.read and File.binread

Source: https://rubystyle.guide/

Prefer File.read for text mode and File.binread for binary mode when reading a file from start to finish. Avoid File.open with read modes 'r', 'rt', 'r+', 'r+t' for text and 'rb', 'r+b' for binary.

```ruby
## text mode
# bad (only when reading from beginning to end - modes: 'r', 'rt', 'r+', 'r+t')
File.open(filename).read
File.open(filename, &:read)
File.open(filename) { |f| f.read }
File.open(filename) do |f|
  f.read
end
File.open(filename, 'r').read
File.open(filename, 'r', &:read)
File.open(filename, 'r') { |f| f.read }
File.open(filename, 'r') do |f|
  f.read
end

# good
File.read(filename)

## binary mode
# bad (only when reading from beginning to end - modes: 'rb', 'r+b')
File.open(filename, 'rb').read
File.open(filename, 'rb', &:read)
File.open(filename, 'rb') { |f| f.read }
File.open(filename, 'rb') do |f|
  f.read
end

# good
File.binread(filename)
```

--------------------------------

### Avoid semicolon in if; use ternary

Source: https://rubystyle.guide/

Shows bad and good examples of using a semicolon in an if statement. The bad example uses if x; ... while the good example uses a ternary operator.

```ruby
# bad
result = if some_condition; something else something_else end

# good
result = some_condition ? something : something_else
```

--------------------------------

### Writing to a file: use File.write and File.binwrite

Source: https://rubystyle.guide/

Prefer File.write for text mode and File.binwrite for binary mode when creating or replacing file content. Avoid File.open with truncating modes 'w', 'wt', 'w+', 'w+t' for text and 'wb', 'w+b' for binary.

```ruby
## text mode
# bad (only truncating modes: 'w', 'wt', 'w+', 'w+t')
File.open(filename, 'w').write(content)
File.open(filename, 'w') { |f| f.write(content) }
File.open(filename, 'w') do |f|
  f.write(content)
end

# good
File.write(filename, content)

## binary mode
# bad (only truncating modes: 'wb', 'w+b')
File.open(filename, 'wb').write(content)
File.open(filename, 'wb') { |f| f.write(content) }
File.open(filename, 'wb') do |f|
  f.write(content)
end

# good
File.binwrite(filename, content)
```

--------------------------------

### Self-assignment Operators - Bad and Good Examples

Source: https://rubystyle.guide/

Shows discouraged explicit self-assignment and the preferred shorthand operators for arithmetic, logical OR, and logical AND.

```Ruby
# bad
x = x + y
x = x * y
x = x**y
x = x / y
x = x || y
x = x && y

# good
x += y
x *= y
x **= y
x /= y
x ||= y
x &&= y
```

--------------------------------

### Avoid nested ternary operators

Source: https://rubystyle.guide/

Shows bad and good examples of handling nested conditions. The bad example uses a nested ternary, while the good example uses an if/else construct.

```ruby
# bad
some_condition ? (nested_condition ? nested_something : nested_something_else) : something_else

# good
if some_condition
  nested_condition ? nested_something : nested_something_else
else
  something_else
end
```

--------------------------------

### Use Kernel#loop for infinite loops

Source: https://rubystyle.guide/

Shows bad and good examples for using Kernel#loop instead of while/until for infinite loops.

```ruby
# bad
while true
  do_something
end

until false
  do_something
end

# good
loop do
  do_something
end

```

--------------------------------

### No Trailing Array Commas: Avoid trailing commas in array/hash literals

Source: https://rubystyle.guide/

Shows bad examples with trailing commas and a good example without. The first bad example uses a multi-line array with a trailing comma.

```ruby
# bad - easier to move/add/remove items, but still not preferred
VALUES = [
           1001,
           2020,
           3333,
         ]

# bad
VALUES = [1001, 2020, 3333, ]

# good
VALUES = [1001, 2020, 3333]
```

--------------------------------

### Don't suppress exceptions

Source: https://rubystyle.guide/

Avoid suppressing exceptions. The bad example rescues without handling; good examples handle the exception or add a comment explaining why handling is not performed. The last good example uses rescue as a modifier.

```ruby
# bad
begin
  do_something # an exception occurs here
rescue SomeError
end

# good
begin
  do_something # an exception occurs here
rescue SomeError
  handle_exception
end

# good
begin
  do_something # an exception occurs here
rescue SomeError
  # Notes on why exception handling is not performed
end

# good
do_something rescue nil
```

--------------------------------

### Use loop with break for post-loop tests

Source: https://rubystyle.guide/

Shows bad and good examples for using Kernel#loop with break instead of begin/end/until or begin/end/while for post-loop tests.

```ruby
# bad
begin
  puts val
  val += 1
end while val < 0

# good
loop do
  puts val
  val += 1
  break unless val < 0
end

```

--------------------------------

### Avoid for loops; use each

Source: https://rubystyle.guide/

Shows bad and good examples of iterating over an array. The bad example uses a for loop, which does not introduce a new scope, so the loop variable remains accessible after the loop. The good example uses each, where the block variable is not accessible outside.

```ruby
arr = [1, 2, 3]

# bad
for elem in arr do
  puts elem
end

# note that elem is accessible outside of the for loop
elem # => 3

# good
arr.each { |elem| puts elem }

# elem is not accessible outside each block
elem # => NameError: undefined local variable or method `elem'
```

--------------------------------

### Prefer raise over fail

Source: https://rubystyle.guide/

Use raise instead of fail for exceptions. The bad example uses fail, the good example uses raise.

```ruby
# bad
fail SomeException, 'message'

# good
raise SomeException, 'message'
```

--------------------------------

### %w: Prefer %w for arrays of words

Source: https://rubystyle.guide/

Shows bad and good ways to create an array of strings. The good example uses %w with brackets.

```ruby
# bad
STATES = ['draft', 'open', 'closed']

# good
STATES = %w[draft open closed]
```

--------------------------------

### Curlies Interpolate

Source: https://rubystyle.guide/

Always include {} around instance and global variables in string interpolation. The bad examples omit braces, while the good examples include them.

```ruby
class Person
  attr_reader :first_name, :last_name

  def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
  end

  # bad - valid, but awkward
  def to_s
    "#@first_name #@last_name"
  end

  # good
  def to_s
    "#{@first_name} #{@last_name}"
  end
end

$global = 0
# bad
puts "$global = #$global"

# good
puts "$global = #{$global}"
```

--------------------------------

### Prefer predicate methods over == comparisons

Source: https://rubystyle.guide/

Shows bad and good examples. Use predicate methods like even?, odd?, nil?, zero? instead of explicit == comparisons. Numeric comparisons are OK.

```Ruby
# bad
if x % 2 == 0
end

if x % 2 == 1
end

if x == nil
end

# good
if x.even?
end

if x.odd?
end

if x.nil?
end

if x.zero?
end

if x == 0
end
```

--------------------------------

### Keyword Arguments vs Option Hashes: Use Keyword Arguments Instead

Source: https://rubystyle.guide/

Use keyword arguments instead of option hashes. The example shows bad and good method definitions.

```Ruby
# bad
def some_method(options = {})
  bar = options.fetch(:bar, false)
  puts bar
end

# good
def some_method(bar: false)
  puts bar
end
```

--------------------------------

### String Interpolation vs Concatenation

Source: https://rubystyle.guide/

Prefer string interpolation or format over string concatenation. The bad example uses +, while the good examples use interpolation and format.

```ruby
# bad
email_with_name = user.name + ' <' + user.email + '>'

# good
email_with_name = "#{user.name} <#{user.email}>"

# good
email_with_name = format('%s <%s>', user.name, user.email)
```

--------------------------------

### Use File::NULL for platform-independent null device

Source: https://rubystyle.guide/

Use File::NULL instead of hardcoding '/dev/null' or 'NUL' to ensure cross-platform compatibility. The bad examples show platform-specific or ternary-based approaches.

```ruby
# bad - hardcoded devices are platform specific
File.open("/dev/null", 'w') { ... }

# bad - unnecessary ternary can be replaced with `File::NULL`
File.open(Gem.win_platform? ? 'NUL' : '/dev/null', 'w') { ... }

# good - platform independent
File.open(File::NULL, 'w') { ... }
```

--------------------------------

### Use Hash#values_at or Hash#fetch_values for consecutive hash retrieval

Source: https://rubystyle.guide/

Shows bad and good examples for retrieving several values from a hash. Prefer values_at or fetch_values over manual assignment or mapping keys.

```ruby
# bad
email = data['email']
username = data['nickname']

# bad
keys = %w[email nickname].freeze
email, username = keys.map { |key| data[key] }

# good
email, username = data.values_at('email', 'nickname')

# also good
email, username = data.fetch_values('email', 'nickname')
```

--------------------------------

### Semicolon Usage: Bad vs Good

Source: https://rubystyle.guide/

Avoid using semicolons to terminate statements. The bad example shows a superfluous semicolon; the good example omits it.

```Ruby
# bad
puts 'foobar'; # superfluous semicolon

# good
puts 'foobar'
```

--------------------------------

### String Concatenation

Source: https://rubystyle.guide/

Use String#<< instead of String#+ for large data chunks because it mutates in-place and is faster. The bad example uses +=, the good example uses <<.

```ruby
# bad
html = ''
html += '<h1>Page title</h1>'

paragraphs.each do |paragraph|
  html += "<p>#{paragraph}</p>"
end

# good and also fast
html = ''
html << '<h1>Page title</h1>'

paragraphs.each do |paragraph|
  html << "<p>#{paragraph}</p>"
end
```

--------------------------------

### Avoid optional hash params

Source: https://rubystyle.guide/

Shows bad and good examples. Use keyword arguments instead of hashes as optional parameters, except for object initializers.

```Ruby
# bad
def send_email(subject, opts = {})
  to = opts[:to]
  cc = opts[:cc]
  # ...
end

# good
def send_email(subject, to:, cc: nil)
  # ...
end
```

--------------------------------

### Symbols as Keys: Prefer symbols over strings as hash keys

Source: https://rubystyle.guide/

Shows bad and good ways to define hash keys. The good example uses symbol keys with the colon syntax.

```ruby
# bad
hash = { 'one' => 1, 'two' => 2, 'three' => 3 }

# good
hash = { one: 1, two: 2, three: 3 }
```

--------------------------------

### Avoid rescue as a modifier

Source: https://rubystyle.guide/

Avoid using rescue in its modifier form. The bad example catches StandardError and descendants; the good example catches only Errno::ENOENT and descendants.

```ruby
# bad - this catches exceptions of StandardError class and its descendant classes
read_file rescue handle_error($!)

# good - this catches only the exceptions of Errno::ENOENT class and its descendant classes
def foo
  read_file
rescue Errno::ENOENT => e
  handle_error(e)
end
```

--------------------------------

### Multi-line Regular Expressions in Ruby

Source: https://rubystyle.guide/

Use the x (free-spacing) modifier for multi-line regexps. Shows a bad example with escaped newlines and a good example using the x modifier.

```ruby
# bad
regex = /start\
\s\
(group)\
(?:alt1|alt2)\
end/

# good
regexp = /
  start
  \s
  (group)
  (?:alt1|alt2)
  end
/x
```

--------------------------------

### Use alternate reader methods to avoid nil access

Source: https://rubystyle.guide/

Shows bad and good examples for accessing elements. Avoid direct access via [n] by using alternate reader methods to guard against nil.

```ruby
# bad
Regexp.last_match[1]

# good
Regexp.last_match(1)
```

--------------------------------

### Use Hash#transform_keys and Hash#transform_values for hash transformations

Source: https://rubystyle.guide/

Shows bad and good examples for transforming hash keys or values. Prefer transform_keys or transform_values over each_with_object or map.

```ruby
# bad
{a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[k] = v * v }
{a: 1, b: 2}.map { |k, v| [k.to_s, v] }.to_h

# good
{a: 1, b: 2}.transform_values { |v| v * v }
{a: 1, b: 2}.transform_keys { |k| k.to_s }
```

--------------------------------

### Prefer Non-capturing Groups in Ruby Regexps

Source: https://rubystyle.guide/

Use non-capturing groups (?:...) when the captured result is not used. Shows a bad example with capturing group and a good example with non-capturing group.

```ruby
# bad
/(first|second)/

# good
/(?:first|second)/
```

--------------------------------

### Don't use exceptions for flow control

Source: https://rubystyle.guide/

Avoid using exceptions for flow control. The bad example uses a rescue for division by zero; the good example uses a conditional check.

```ruby
# bad
begin
  n / d
rescue ZeroDivisionError
  puts 'Cannot divide by 0!'
end

# good
if d.zero?
  puts 'Cannot divide by 0!'
else
  n / d
end
```

--------------------------------

### Avoid END blocks; use at_exit

Source: https://rubystyle.guide/

Shows the discouraged use of END blocks and the preferred Kernel#at_exit alternative.

```ruby
# bad
END { puts 'Goodbye!' }

# good
at_exit { puts 'Goodbye!' }
```

--------------------------------

### Order rescue clauses from specific to general

Source: https://rubystyle.guide/

Put more specific exceptions higher up the rescue chain. The bad example has StandardError before IOError, so IOError is never rescued; the good example reverses the order.

```ruby
# bad
begin
  # some code
rescue StandardError => e
  # some handling
rescue IOError => e
  # some handling that will never be executed
end

# good
begin
  # some code
rescue IOError => e
  # some handling
rescue StandardError => e
  # some handling
end
```

--------------------------------

### Prefer unless over if for negative conditions

Source: https://rubystyle.guide/

Shows bad and good examples for using unless instead of if with negative conditions. Also shows using || as an alternative control flow.

```ruby
# bad
do_something if !some_condition

# bad
do_something if not some_condition

# good
do_something unless some_condition

# another good option
some_condition || do_something

```

--------------------------------

### Avoid blind rescues

Source: https://rubystyle.guide/

Avoid rescuing the Exception class because it traps signals and exit calls. The bad example rescues Exception; good examples rescue StandardError or use a bare rescue.

```ruby
# bad
begin
  # calls to exit and kill signals will be caught (except kill -9)
  exit
rescue Exception
  puts "you didn't really want to exit, right?"
  # exception handling
end

# good
begin
  # a blind rescue rescues from StandardError, not Exception as many
  # programmers assume.
rescue => e
  # exception handling
end

# also good
begin
  # an exception occurs here
rescue StandardError => e
  # exception handling
end
```

--------------------------------

### Trailing Comma in Method Arguments

Source: https://rubystyle.guide/

Shows bad and good examples of avoiding a comma after the last parameter in a method call. The bad examples include a trailing comma on separate lines and on the same line.

```ruby
# bad - easier to move/add/remove parameters, but still not preferred
some_method(
  size,
  count,
  color,
)

# bad
some_method(size, count, color, )

# good
some_method(size, count, color)
```

--------------------------------

### Using Regular Expressions as String Indexes in Ruby

Source: https://rubystyle.guide/

Use regexp directly through string index for simple constructions. Shows how to get matched content, captured groups, and replace matched content.

```ruby
match = string[/regexp/]             # get content of matched regexp
first_group = string[/text(grp)/, 1] # get content of captured group
string[/text (grp)/, 1] = 'replace'  # string => 'text replace'
```

--------------------------------

### Single-line Classes: Prefer Two-line Format for Class Definitions with No Body

Source: https://rubystyle.guide/

Prefer a two-line format for class definitions with no body. The bad example uses Class.new(StandardError), the okish example uses a single-line class, and the ok example uses a two-line format. Note that many editors/tools may fail to understand Class.new, and the class name is not available to the inherited callback with that form.

```ruby
# bad
FooError = Class.new(StandardError)

# okish
class FooError < StandardError; end

# ok
class FooError < StandardError
end
```

--------------------------------

### Atomic file operations: use mkdir_p and rm_f

Source: https://rubystyle.guide/

Avoid race conditions by using atomic and idempotent operations. Use FileUtils.mkdir_p instead of checking Dir.exist? and FileUtils.rm_f instead of checking File.exist?.

```ruby
# bad - race condition with another process may result in an error in `mkdir`
unless Dir.exist?(path)
  FileUtils.mkdir(path)
end

# good - atomic and idempotent creation
FileUtils.mkdir_p(path)

# bad - race condition with another process may result in an error in `remove`
if File.exist?(path)
  FileUtils.remove(path)
end

# good - atomic and idempotent removal
FileUtils.rm_f(path)
```

--------------------------------

### Avoid Numbered Groups in Ruby Regexps

Source: https://rubystyle.guide/

Avoid numbered groups because they are hard to track. Use named groups instead. Shows a bad example with Regexp.last_match(1) and a good example with a named variable.

```ruby
# bad
/(regexp)/ =~ string
# some code
process Regexp.last_match(1)

# good
/(?<meaningful_var>regexp)/ =~ string
# some code
process meaningful_var
```

--------------------------------

### Keyword Arguments vs Optional Arguments: Prefer Keyword Arguments

Source: https://rubystyle.guide/

Prefer keyword arguments over optional arguments. The example shows bad and good method definitions.

```Ruby
# bad
def some_method(a, b = 5, c = 1)
  # body omitted
end

# good
def some_method(a, b: 5, c: 1)
  # body omitted
end
```

--------------------------------

### Empty Lines around Bodies

Source: https://rubystyle.guide/

Shows bad and good examples of avoiding empty lines around method, class, module, and block bodies. The good example removes all unnecessary empty lines.

```ruby
# bad
class Foo

  def foo

    begin

      do_something do

        something

      end

    rescue

      something

    end

    true

  end

end

# good
class Foo
  def foo
    begin
      do_something do
        something
      end
    rescue
      something
    end
  end
end
```
Tokens:
Raw