Fueling Curiosity, One Insight at a Time

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

EXPLAIN ANALYZE select * from public.card
where card_number='120000024223'

Seq Scan on public.card  (cost=0.00..11.75 rows=1 width=180) (actual time=0.016..0.018 rows=1 loops=1)
  Filter: ((card_number)::text = '120000024223'::text)
Rows Removed by Filter: 100
Planning Time: 0.152 ms
Execution Time: 0.034 ms

RSpec.shared_context "user and post setup", shared_context: :metadata do
  let(:user) { User.create(name: "Alice") }
  let(:post) { Post.create(title: "First Post", user: user) }
end

RSpec.describe "Using shared context in tests" do
  include_context "user and post setup"

  it "has a user with a name" do
    expect(user.name).to eq("Alice")
  end

  it "has a post with a title" do
    expect(post.title).to eq("First Post")
  end
end

SELECT DISTINCT ON (user_id, event_name) id, user_id, event_name, inquiry_id, created_at
FROM public.persona_inquiry
ORDER BY user_id, event_name, created_at DESC;

class Current < ActiveSupport::CurrentAttributes
  attribute :role
end

class ApplicationController < ActionController::Base  
  before_action :set_current_attributes

  def set_current_attributes
    Current.role = session[:role]
    // ... other attributes
  end
end

mise use -g ruby@3

curl https://mise.run | sh

echo 'eval "$(~/.local/bin/mise activate)"' >> ~/.zshrc

source ~/.zshrc

class MyClass
  mattr_accessor :my_variable
end

class MyClass
  @my_variable = nil

  def self.my_variable
    @my_variable
  end

  def self.my_variable=(value)
    @my_variable = value
  end
end

class User < ApplicationRecord
  has_one :profile
  accepts_nested_attributes_for :profile
end

user_params = {
  name: "John Doe",
  profile_attributes: { bio: "Developer", age: 30 }
}

user = User.create(user_params)

# config/initializers/pagy.rb

require "pagy/extras/array"

def index
 // some code
 @pagy, @purchase_order_attachments = pagy_array(orders_with_attachments, items: params[:limit] || 10)
end

class MyClass:
    class_variable = "Class Variable"

    def __init__(self):
        self.instance_variable = "Instance Variable"

    def my_method(self):
        pass

obj = MyClass()
print(dir(obj))

ssh -vT "[email protected]"

let value: string;
console.log(value); // TS4.x: This was allowed but could lead to runtime undefined

let value: string;
console.log(value); // TS5.x: Error - Variable 'value' is used before being assigned

// To fix, either initialize:
let value = "initial";

// Or use definite assignment assertion:
let value!: string;

class UserProfileForm
  include ActiveModel::Model

 # Attributes accessible for the form object.
  attr_accessor :user_name, :email, :profile_bio, :profile_age

  validates :user_name, :email, presence: true
  validates :profile_age, numericality: { only_integer: true, greater_than: 0 }

  def save
    return false unless valid?
    
    #a single transaction for multiple operations
    ActiveRecord::Base.transaction do
      user = User.create!(name: user_name, email: email)
      user.create_profile!(bio: profile_bio, age: profile_age)
    end

    true # Return true if all operations succeed.
  rescue ActiveRecord::RecordInvalid
    false # Return false if the save process fails.
  end
end

class UsersController < ApplicationController
  def new
    @form = UserProfileForm.new
  end

  def create
    @form = UserProfileForm.new(user_profile_form_params)

    if @form.save
      redirect_to root_path, notice: "User created successfully!"
    else
      render :new, status: :unprocessable_entity
    end
  end

  private

  def user_profile_form_params
    params.require(:user_profile_form).permit(:user_name, :email, :profile_bio, :profile_age)
  end
end

openssl pkcs12 -export -out certificate.pfx -inkey privatekey.pem -in certificate.pem -certfile ca-chain.pem

openssl pkcs12 -info -in certificate.pfx