TILs - Fueling Curiosity, One Insight at a Time

touch lib/tasks/custom_tasks.rake

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

bin/rake custom:hello

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

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

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

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
)

const { data: session, update } = useSession();

await update({
  user: {
    ...session?.user,
    name: "Updated Name",
    role: "editor", 
  },
});

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
    }
  }
})

# 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
end

let(:admin_user) { create(:user, :admin) }
let(:guest_user) { create(:user, :guest) }
let(:confirmed_user) { create(:user, :confirmed) }

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!(
  ordered_quantity: new_quantity,
)

item.update!(
  quantity_field => new_quantity,
)

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
)

def some_number
  @some_number
end

attr_reader :some_number

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
 }
}

'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>
 );
}

page.execute_script("arguments[0].scrollIntoView(true)", button)

scroll_to(button)  # Scrolls to the element

"Test".localeCompare("test", undefined, { sensitivity: "base" }) === 0; // ✅ True
"café".localeCompare("cafe", undefined, { sensitivity: "base" }) === 0; // ✅ True
"Hello".localeCompare("HELLO", undefined, { sensitivity: "base" }) === 0; // ✅ True

"base" → Ignores case & accents ("café" == "cafe", "Hello" == "hello")

"accent" → Considers accents but ignores case ("café" != "cafe", "Hello" == "hello")

"case" → Considers case but ignores accents ("café" == "cafe", "Hello" != "hello")

"variant" → Considers both case & accents ("café" != "cafe", "Hello" != "he

expect(page).to have_button("Add Discrepancy", disabled: true, visible: :all)

<% if local_assigns[:show_projects] %> 
  <div class="flex">
    <%= (render @user.projects) || (render 'shared/empty_state', message: "No projects found!") %>
  </div> 
<% end %>

params = ActionController::Parameters.new(posts: [{id: 1}])

params.expect(posts: [[:id]])

[
  #<ActionController::Parameters {"id"=>1} permitted: true>,
  #<ActionController::Parameters {"id"=>2} permitted: true>
]

params = ActionController::Parameters.new(posts: {id: 1})

params.expect(posts: [[:id]])

params.permit(posts: [:id])

"person".pluralize  # => "people"
"person".singularize # => "person"

ActiveSupport::Inflector.inflections(:en) do |inflect|
  inflect.irregular "foot", "feet"
end

// "foot".pluralize  # => "feet"

ActiveSupport::Inflector.inflections(:en) do |inflect|
  inflect.uncountable "milk"
end

// "milk".pluralize  # => "milk"

ActiveSupport::Inflector.inflections(:en) do |inflect|
  inflect.acronym "HTML5"
end

// "html5".camelize  # => "HTML5"