Fueling Curiosity, One Insight at a Time

At Codemancers, we believe every day is an opportunity to grow. This section is where our team shares bite-sized discoveries, technical breakthroughs and fascinating nuggets of wisdom we've stumbled upon in our work.

Mar 19, 2025
in ruby https://nil.to|nil.to_i => 0 & https://nil.to|nil.to_f => 0.0
#ruby, #nil-conversion
satya
Satya
Mar 18, 2025
Steps to merge one repo into another

Step 1: Clone Repo1 locally


git clone  repo1
cd repo1


Step 2: Fetch all the branches and commits from Repo2


git remote add repo2 
git fetch repo2


Step 3: Create a branch


git checkout -b merge-repo2


Step 4: Merge keeping full history


git merge --allow-unrelated-histories repo2/main (Since the repositories have separate histories, this option allows Git to combine them, potentially requiring manual conflict resolution)


Step 5: Resolve Merge Conflicts


git add .
git commit -m "Resolved merge conflicts"


#git
sujay
Sujay
Mar 18, 2025
pagy_array This method is the same as the generic pagy method, but specialized for an Array.


require 'pagy/extras/array'
@pagy, @items = pagy_array(an_array)


#CU6U0R822 #ruby
mohammad.hussain
Mohammad hussain
System Analyst
Mar 18, 2025

```
pagy_array
mohammad.hussain
Mohammad hussain
System Analyst
Mar 13, 2025
each_with_object is an enumerable method in Ruby that allows you to iterate over a collection while building up an object (like an array or hash). Unlike map, which creates a new array, each_with_object lets you modify an existing object in a single pass.

Syntax


collection.each_with_object(initial_object) do |item, object|
  # Modify the object inside the block
end


collection: The array or enumerable you're iterating over.
initial_object: The object that will be modified (e.g., {} for a hash or [] for an array).
item: The current element in the iteration.
object: The object that accumulates the results.
Example Usage
Using each_with_object with a Hash


numbers = [1, 2, 3, 4, 5]
squares = numbers.each_with_object({}) do |num, hash|
  hash[num] = num**2
end

puts squares
# Output: {1=>1, 2=>4, 3=>9, 4=>16, 5=>25}


Why use each_with_object?
• Avoids the need to initialize an empty {} before the loop.
• Eliminates the need to return the object explicitly.

#CU6U0R822 #ruby
nived.hari
Nived Hari
System Analyst
Mar 13, 2025
When to use collection_select over select in rails
Use collection_select when you need to populate a dropdown with a collection of ActiveRecord objects. It is built on top of select and provides a convenient way to display object attributes instead of a simple array of strings.
select is used for manually defining options, typically from an array of strings or key-value pairs.
collection_select is specifically designed for selecting records from an ActiveRecord collection, making it useful when working with database associations.
mohammad.hussain
Mohammad hussain
System Analyst
Mar 12, 2025
Rake tasks in Rails let you run custom scripts from the command line.
You can define your own tasks inside the lib/tasks directory.

How to Create a Custom Rake Task

1. Create a new .rake file in lib/tasks/


touch lib/tasks/custom_tasks.rake


Define the task inside the file:


namespace :custom do
  desc "Say hello from a custom rake task"
  task :hello do
    puts "Hello from custom Rake task!"
  end
end


Run the task from the terminal:


bin/rake custom:hello


Use :environment if your task interacts with the database or models

#CU6U0R822 #rake
nived.hari
Nived Hari
System Analyst
Mar 12, 2025
The inverse_of option in ActiveRecord helps Rails recognize bidirectional associations in memory, reducing redundant database queries.
For example:


class Employee < ApplicationRecord
  belongs_to :department, foreign_key: 'department_code', primary_key: 'code', inverse_of: :employees
end

class Department < ApplicationRecord
  has_many :employees, foreign_key: 'department_code', primary_key: 'code', inverse_of: :department
end


Why Use inverse_of?
• Prevents extra queries when accessing related objects
• Keeps objects in memory, improving performance
• Ensures associated objects reference the same instance
Without inverse_of, Rails may reload the association unnecessarily:



employee = Employee.first
department = employee.department  # Triggers a SQL query
department.employees.include?(employee)  # Without `inverse_of`, this could trigger another query


With inverse_of, Rails avoids the extra query because it knows department.employees already includes employee

#CU6U0R822 #active_record
nived.hari
Nived Hari
System Analyst
Mar 7, 2025
In dry-validation contracts, values is a hash containing all the parameters being validated. When defining rule blocks, you can access specific parameters using hash-like syntax.
Example:


class MyContract < Dry::Validation::Contract
  params do
    required(:category).filled(:string)
  end

  rule(:category) do
    key.failure("is not allowed") unless values[:category] == "approved_value"
  end
end


Key Points:
values holds all input parameters.
• Use values[:key] to access specific parameters inside rule blocks.
• This allows custom validation logic beyond basic schema definitions.
#ruby #dry_validation
nived.hari
Nived Hari
System Analyst
Mar 7, 2025
You can manually send messages to a Kafka topic using Karafka's producer. This is useful for debugging, testing, or custom event handling.
Example:


payload = {
  id: 123,
  name: "Sample Item",
  status: "processed",
  timestamp: 
Time.now.to_i
}

Karafka.producer.produce_sync(
  topic: "your_topic_name",
  payload: payload.to_json
)


Key Points:
produce_sync ensures the message is sent before proceeding.
topic specifies the Kafka topic where the message will be published.
payload should be serialized into JSON or another supported format.
#karafka
nived.hari
Nived Hari
System Analyst

Showing 5 to 7 of 80 results

Ready to Build Something Amazing?

Codemancers can bring your vision to life and help you achieve your goals