10 Basic Ruby/ RoR Prompts to Test in Your Favorite LLM

Detailed Explanation of 10 Ruby and Ruby on Rails Coding Prompts

In this article, we will delve into 10 highly detailed coding prompts focused on Ruby and Ruby on Rails. Each prompt is designed to test various aspects of Ruby programming—from algorithms and data structures to web development with Rails. Below, we explain the purpose of each prompt, the key requirements, and the skills that developers will practice while solving them.

---

1. Ruby Recursive Quicksort Implementation

Prompt:

"Implement a recursive quicksort algorithm in Ruby. Your function should take an array of integers and return a new array sorted in ascending order. Ensure your code handles edge cases such as empty arrays, includes clear inline comments, and leverages Ruby’s expressive syntax."

def quicksort(array)
  return array if array.length <= 1
  pivot = array.delete_at(array.length / 2)
  left, right = array.partition { |x| x < pivot }
  quicksort(left) + [pivot] + quicksort(right)
end

puts quicksort([3, 6, 8, 10, 1, 2, 1]).inspect

Explanation:

This prompt challenges you to implement one of the classic sorting algorithms—quicksort—in Ruby.

• Algorithm Practice: It reinforces your understanding of recursion, partitioning, and sorting logic.
• Edge Cases: Handling empty arrays or single-element arrays is crucial for robust code.
• Ruby Expressiveness: The solution should make use of Ruby’s elegant syntax, potentially leveraging idiomatic constructs like array slicing.
• Commenting: Inline comments are required to explain your thought process and improve code readability.

---

2. Ruby Email Validator Using Regular Expressions

Prompt:

"Write a Ruby method that validates an email address using a regular expression. The method should return true if the email matches a standard email format and false otherwise. Include several test cases (using Minitest or RSpec) to demonstrate the method’s correctness."

def valid_email?(email)
  !!(email =~ /^[\w.+\-]+@\w+\.\w{2,}$/)
end

puts valid_email?("[e-mail]") # true
puts valid_email?("invalid-email") # false

Explanation:

This task is designed to test your skills in pattern matching using Ruby’s regex capabilities.

• Regex Mastery: You must write a robust regular expression that accurately identifies valid email formats.
• Return Value: The method should clearly return a boolean value based on validation.
• Testing: Including unit tests using frameworks like Minitest or RSpec demonstrates not only your implementation skills but also your ability to write tests for edge cases (e.g., missing '@' or domain parts).

---

3. Rails ActiveRecord Query for Top Users

Prompt:

"In a Ruby on Rails application with a User model, write an ActiveRecord query to retrieve the top 5 users based on their score attribute. Ensure the query only includes active users (e.g., active: true) and sorts them in descending order of score. Provide the code snippet and explain how ActiveRecord handles the query building."

User.where(active: true).order(score: :desc).limit(5)

Explanation:

This prompt emphasizes the use of ActiveRecord in Rails.

• Query Construction: You must build a query that filters and orders data effectively.
• Model Scope: Filtering by active: true ensures that only users meeting a specific condition are included.
• Sorting and Limiting: Ordering users by their score in descending order and limiting the results to the top 5 helps practice chainable query methods.
• Educational Aspect: Explaining how ActiveRecord transforms your Ruby code into SQL queries deepens your understanding of the framework.

---

4. Rails API for Managing Books

Prompt:

"Create a Ruby on Rails API-only application that supports CRUD operations for a Book resource. Use Rails’ built-in scaffold generator to set up the model, controller, and routes. Enhance the controller with custom error handling and validation responses in JSON format. Document how to test each endpoint with curl or Postman."

rails new book_api --api
cd book_api
rails generate scaffold Book title:string author:string
rails db:migrate
rails s

Explanation:

This prompt is aimed at building a RESTful API using Rails.

• CRUD Operations: The application must allow Create, Read, Update, and Delete functionalities for books.
• Scaffolding: Utilizing Rails scaffolding speeds up initial setup while ensuring you understand the generated code.
• Error Handling: Custom error messages and validation ensure that the API returns useful feedback when operations fail.
• API Testing: Documenting the endpoints and providing instructions on using tools like curl or Postman reinforces real-world API testing practices.

---

5. Ruby Stack Data Structure with Unit Tests

Prompt:

"Implement a basic stack data structure in Ruby using an array. The class should include methods for push, pop, peek, and empty?. Write unit tests using RSpec to verify the correct behavior of each method, ensuring edge cases (such as popping from an empty stack) are properly handled."

class Stack
  def initialize
    @stack = []
  end

  def push(value)
    @stack.push(value)
  end

  def pop
    @stack.pop
  end

  def peek
    @stack.last
  end

  def empty?
    @stack.empty?
  end
end

s = Stack.new
s.push(10)
puts s.peek # 10
puts s.pop  # 10
puts s.empty? # true

Explanation:

This task focuses on building a fundamental data structure— the stack—from scratch.

• Data Structure Implementation: You must implement core operations of a stack.
• Edge Case Handling: Consider scenarios like attempting to pop an element from an empty stack.
• Testing: Writing unit tests with RSpec not only verifies functionality but also practices test-driven development (TDD).

---

6. Ruby Script for Fetching and Parsing API Data

Prompt:

"Write a Ruby script that uses the Net::HTTP or Faraday library to fetch JSON data from a public API (e.g., the GitHub API). Parse the JSON response to extract specific fields (like repository name, star count, and description) and print the results in a formatted output. Include error handling for network issues and invalid responses."

require 'net/http'
require 'json'

url = URI("https://api.github.com/repos/rails/rails")
response = Net::HTTP.get(url)
data = JSON.parse(response)
puts "Repo: #{data["name"]}, Stars: #{data["stargazers_count"]}"

Explanation:

This prompt helps you practice interacting with external APIs in Ruby.

• HTTP Requests: Use libraries like Net::HTTP or Faraday to make HTTP GET requests.
• JSON Parsing: Extract and format specific fields from the JSON response.
• Error Handling: Robust error handling is required to manage network issues and malformed responses, ensuring your script is resilient.
• Practical Application: This is a common task when integrating third-party APIs in real-world applications.

---

7. Converting Legacy Ruby Code to Use Modern Syntax

Prompt:

"Given a snippet of legacy Ruby code that uses older hash syntax and manual iteration, refactor it to use modern Ruby features such as the new hash syntax, enumerable methods (like map, select), and safe navigation operators. Provide both the original and refactored code with inline comments explaining each change."

# Old Ruby Code
hash = {:name => "John", :age => 30}

def filter_adults(people)
  adults = []
  people.each do |person|
    adults << person if person[:age] >= 18
  end
  adults
end

# Refactored Code
hash = {name: "John", age: 30}

def filter_adults(people)
  people.select { |person| person[:age] >= 18 }
end

Explanation:

This exercise is centered on refactoring and modernizing existing code.

• Legacy to Modern: Transition from older Ruby practices to current standards.
• Improved Readability: Using new hash syntax and enumerable methods makes the code more concise and expressive.
• Documentation: Inline comments should clearly explain why each change is made, enhancing maintainability.
• Best Practices: Understanding modern Ruby idioms is critical for writing clean and efficient code.

---

8. Rails Security Enhancement: Preventing SQL Injection

Prompt:

"Review a Rails controller action that constructs SQL queries with string interpolation. Refactor the code to use parameterized queries or ActiveRecord query methods to prevent SQL injection vulnerabilities. Explain the changes made and why they enhance the security of the application."

# Insecure
User.where("email = '#{params[:email]}'")

# Secure
User.where(email: params[:email])

Explanation:

This prompt emphasizes the importance of security in web applications.

• Security Focus: Identifying and mitigating SQL injection risks by refactoring insecure code.
• ActiveRecord Advantages: Utilize ActiveRecord’s parameterized queries to ensure user input is safely handled.
• Educational Value: Explaining the security improvements reinforces the importance of writing secure code and understanding potential vulnerabilities in Rails applications.

---

9. Rails Application with Paginated Results

Prompt:

"Build a Ruby on Rails application that displays a list of Article records on an index page. Integrate pagination using a gem like kaminari or will_paginate. The controller should load only the necessary records per page, and the view should provide navigation links to move between pages. Include code snippets for the controller, model, and view, as well as instructions on gem configuration."

# Gemfile
# gem 'kaminari'

@articles = Article.page(params[:page]).per(10)

Explanation:

This task introduces pagination in Rails, a common feature for handling large datasets.

• Pagination Gems: Learn to integrate and configure popular pagination gems such as kaminari or will_paginate.
• Efficient Data Loading: The controller should fetch only the records needed for the current page, optimizing performance.
• User Experience: Navigation links in the view enhance usability by allowing users to easily move through pages.
• Documentation: Including clear configuration instructions and code snippets ensures that the solution is replicable.

---

10. Ruby Multithreading: Parallel Sum Calculation

Prompt:

"Implement a Ruby script that calculates the sum of a large array of integers using multiple threads. Divide the array into segments processed in parallel, then combine the results to get the final sum. Ensure proper synchronization (if needed) and demonstrate how Ruby threads can be used to improve performance, despite the Global Interpreter Lock (GIL). Provide a discussion on when multithreading is effective in Ruby."

array = (1..100).to_a
threads = []
sum = 0
mutex = Mutex.new

array.each_slice(10) do |slice|
  threads << Thread.new do
    partial_sum = slice.sum
    mutex.synchronize { sum += partial_sum }
  end
end

threads.each(&:join)
puts sum

Explanation:

This prompt explores concurrency in Ruby.

• Parallel Processing: The array is divided into segments to be processed concurrently, demonstrating thread usage.
• Synchronization: Proper synchronization mechanisms (like mutexes) must be used to avoid race conditions when combining results.
• GIL Consideration: Despite Ruby’s Global Interpreter Lock (GIL), this exercise shows scenarios where multithreading can still be beneficial (e.g., I/O-bound tasks).
• Discussion: A discussion on the effectiveness of multithreading in Ruby is included to provide context and best practices for concurrent programming.

---

Conclusion

These 10 prompts cover a broad spectrum of Ruby and Ruby on Rails skills—from algorithm implementation and data structure design to API integration and web application security. By tackling these challenges, you will not only enhance your coding proficiency but also gain a deeper understanding of best practices and modern Ruby idioms. Whether you're a beginner or an experienced developer, these exercises provide valuable opportunities to refine your skills and build robust, maintainable applications.