The most important feature that was released in Ruby 2.7 was Pattern Matching. This feature is common in most functional programming languages such as Scala, Elixir, etc.
In Ruby, Pattern matching is the way to recognize a pattern of data
and execute some actions if the data matches the pattern.
Pattern matching in Ruby is performed using the case statement
wherein the keyword in is used instead of when to match patterns.
An example of pattern matching in Ruby,
case ['apple', 'mango', 'orange', 'guava']
in ['mango', 'apple', 'orange', 'guava']
puts "Fruits in incorrect order"
in ['apple', 'mango', 'orange', 'guava']
puts "Fruits in correct order"
end
#=> "Fruits in the correct order"
case [1, 2, 3, 4]
in [1, 3, *other_numbers]
puts "Incorrect match"
in [1, *other_numbers]
puts "Correct match"
puts other_numbers
end
#=> "Correct match"
#=> 2
#=> 3
#=> 4
point = { x: 1, y: 2, z: 3 }
case point
in { x:, y:, z: }
puts "The points are #{x}, #{y}, #{z}"
else
puts "The pattern are not matched correctly"
end
#=> "The points are 1, 2, 3"This feature was introduced in 2.7 and the Ruby community loves this feature as it makes the code more readable. Rails will now allow the same pattern matching feature against ActiveModel (also ActiveRecord) objects.
To understand how this could help the Rails codebase, let’s take an example of a User model with the following attributes-
- type
- preferred_full_name
- first_name
- last_name
class User
include ActiveModel::AttributeMethods
attr_accessor :type, :preferred_full_name, :first_name, :last_name
endWe need to define a method to get a User’s full name but with the following conditions
- If
typeis “Employer”, then return “Name not required” - If
typeis “Employee” andpreferred_full_nameis given then return thepreferred_full_name - If
typeis “Employee” andfirst_nameandlast_nameis given, then return the full name withfirst_nameand thelast_name - If none of these scenarios are matched, return “Name not found”
Before
Before it’s latest version, the following code was used to create this method-
def get_employee_name(user)
if user[:type] == "Employer"
return "Name not required"
elsif user[:type] == "Employee"
if user[:preferred_full_name]
return user[:preferred_full_name]
elsif user[:first_name] && user[:last_name]
return "#{user[:first_name]} #{user[:last_name]}"
end
end
return "Name not found"
endAfter
After the latest Rails version is released, the above method can become more readable using Pattern Matching.
def get_employee_name(user)
case user
in { type: "Employer" }
return "Name not required"
in { type: "Employee", preferred_full_name: }
return preferred_full_name
in { first_name:, last_name: }
return "#{first_name} #{last_name}"
else
return "Name not found"
end
end
user = User.new(type: "Employer", preferred_full_name: "Smith John", first_name: "John", last_name: "Smith")
get_employee(user) #=> "Name not required"
user = User.new(type: "Employee", preferred_full_name: "Smith John", first_name: "John", last_name: "Smith")
get_employee(user) #=> "Smith John"
user = User.new(type: "Employee", first_name: "John", last_name: "Smith")
get_employee(user) #=> "John Smith"
user = User.new(type: "Employee")
get_employee(user) #=> "Name not found"The above method makes the code more readable and easy to understand. This enhancement helps a lot in writing methods with complex logic much easier.
Note: The enhancement is yet to be released in the official Rails version
Check out the PR for more details.
