The workaround this is to just have unique id for element you want to modify and use turbosteam to modify only that element.
#rubyonrails #turbo #turboframes #spa
TILs
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.
https://nil.to|nil.to_i => 0 & https://nil.to|nil.to_f => 0.0Code
git clone <repo1-url> repo1
cd repo1Code
git remote add repo2 <repo2-url>
git fetch repo2Code
git checkout -b merge-repo2Code
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)Code
git add .
git commit -m "Resolved merge conflicts"pagy_array This method is the same as the generic pagy method, but specialized for an Array.Ruby
require 'pagy/extras/array'
@pagy, @items = pagy_array(an_array)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.Ruby
collection.each_with_object(initial_object) do |item, object|
# Modify the object inside the block
endcollection: 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.each_with_object with a HashRuby
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}each_with_object?{} before the loop.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.lib/tasks directory..rake file in lib/tasks/ Code
touch lib/tasks/custom_tasks.rakeCode
namespace :custom do
desc "Say hello from a custom rake task"
task :hello do
puts "Hello from custom Rake task!"
end
endCode
bin/rake custom:hello:environment if your task interacts with the database or modelsinverse_of option in ActiveRecord helps Rails recognize bidirectional associations in memory, reducing redundant database queries.Code
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
endinverse_of?inverse_of, Rails may reload the association unnecessarily:Code
employee = Employee.first
department = employee.department # Triggers a SQL query
department.employees.include?(employee) # Without `inverse_of`, this could trigger another queryinverse_of, Rails avoids the extra query because it knows department.employees already includes employeedry-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.Ruby
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
endvalues holds all input parameters.values[:key] to access specific parameters inside rule blocks.Ruby
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
)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.Paris is the capital of France, known for the Eiffel Tower.Paris is the capital of France, known for the Eiffel Tower.update function from useSession(). Here's how you can modify user details dynamically:JavaScript
const { data: session, update } = useSession();
await update({
user: {
...session?.user,
name: "Updated Name",
role: "editor",
},
});strategy: "jwt" is used, the update() method will trigger a jwt callback with the trigger: "update" option. You can use this to update the session object on the server.JavaScript
export default NextAuth({
callbacks: {
// Using the `...rest` parameter to be able to narrow down the type based on `trigger`
jwt({ token, trigger, session }) {
if (trigger === "update" && session?.name) {
// Note, that `session` can be any arbitrary object, remember to validate it!
token.name = session.name
token.role = session.role
}
return token
}
}
})Ruby
# spec/factories/users.rb
FactoryBot.define do
factory :user do
first_name { Faker::Name.first_name }
email { Faker::Internet.unique.email }
password { "password123" }
trait :admin do
role { "admin" }
end
trait :guest do
role { "guest" }
end
trait :confirmed do
confirmed_at { Time.current }
end
end
endRuby
let(:admin_user) { create(:user, :admin) }
let(:guest_user) { create(:user, :guest) }
let(:confirmed_user) { create(:user, :confirmed) }public_send allows calling a method dynamically when its name is stored in a variable.public_send?Ruby
quantity_field = item.respond_to?(:ordered_quantity) ? :ordered_quantity : :quantity
new_quantity = item.public_send(quantity_field).to_i + item_case[:quantity].to_iitem has ordered_quantity, it calls item.ordered_quantityitem.quantityif-else statements:) – Creates a Literal Symbol KeyRuby
item.update!(
ordered_quantity: new_quantity,
):ordered_quantity).=>) – Evaluates the Left-Hand Side as a KeyRuby
item.update!(
quantity_field => new_quantity,
)Ruby
quantity_field = item.respond_to?(:ordered_quantity) ? :ordered_quantity : :quantity
new_quantity = item.public_send(quantity_field).to_i + item_case[:quantity].to_i
item.update!(
quantity_field => new_quantity, # Evaluates to :ordered_quantity or :quantity
)quantity_field is determined dynamically based on the model, so => must be used instead of :.=>?: when the key is static and always the same.=> when the key is stored in a variable or needs to be evaluated dynamically.attr_reader automatically creates a getter method for instance variables, making code cleaner and more concise. Instead of writing:Ruby
def some_number
@some_number
endRuby
attr_reader :some_numberCode
import { Controller, Post, Body, Res } from '@nestjs/common';
import { openai } from '@ai-sdk/openai';
import { streamText } from 'ai';
import { Response } from 'express';
@Controller('orchestrator')
export class OrchestratorController {
@Post('chat')
async chat(@Body() payload: any, @Res() res: Response) {
const { messages } = payload;
const result = streamText({
model: openai('gpt-4o'),
messages,
});
result.pipeDataStreamToResponse(res); // Streams the AI response directly to the client
}
}Code
'use client';
import { useChat } from '@ai-sdk/react';
export default function Home() {
const { messages, input, handleInputChange, handleSubmit } = useChat({
api: 'https://localhost:3000/api/orchestrator/chat', // make the post request to the NestJS backend
});
return (
<div>
{messages.map((message) => (
<div key={message.id}>
{message.role === 'user' ? 'User: ' : 'AI: '}
{message.content}
</div>
))}
<form onSubmit={handleSubmit}>
<input
name="prompt"
value={input}
onChange={handleInputChange}
className="text-black"
/>
<button type="submit">Submit</button>
</form>
</div>
);
}Showing page 5 of 42
AI is everywhere but it's unclear which investments will actually move your metrics and which are expensive experiments.
Most AI projects fail at the data layer. Pipelines, quality, access all need work before LLMs can deliver value.
Your engineers are shipping product. They don't have capacity to also become AI specialists with production-grade experience.
Aging, undocumented codebases make AI integration slow, risky, and expensive. They need to move first.
Don't worry. We've got you covered.
Start with the audit.