Fueling Curiosity, One Insight at a Time

rails_representation_url in Rails is used to generate a URL for a variant of an Active Storage image, not the original blob. It's especially useful when we want to apply transformations like resizing or converting image formats on-the-fly.

rails_representation_url(
  image.variant(resize_to_limit: [300, 300], saver: { quality: 80 }, format: :webp).processed,
  only_path: true
)

• image.variant(...) creates a variant of the image, resizing it to a maximum of 300x300 pixels, converting it to WebP format, and reducing its quality for optimization.
• .processed ensures the variant is actually processed before generating the URL.
• rails_representation_url(...) then generates the URL for this transformed version.
• only_path: true returns a relative path (instead of a full URL), which is often preferred in views or frontend routing.
This is a great way to deliver performance-optimized images for the UI

#rubyonrails

Rails provides a https://api.rubyonrails.org/classes/ActiveRecord/TokenFor.html#method-i-generate_token_for|generates_token_for method on Active Record models, which can generate unique tokens for records — including support for expiration. This is useful for scenarios like creating unique unsubscribe links in emails. You can later retrieve a record using the generated token with the corresponding https://api.rubyonrails.org/classes/ActiveRecord/TokenFor/RelationMethods.html#method-i-find_by_token_for|find_by_token_for method.

The Rails Authentication generator utilizes this feature in its password reset flow. It uses https://api.rubyonrails.org/classes/ActiveModel/SecurePassword/ClassMethods.html#method-i-has_secure_password|has_secure_password, which by default enables password reset functionality for the user model. When you call the password_reset_token instance method on a user, it internally uses generates_token_for to generate a unique token. You can then find the user record later using find_by_password_reset_token.

By default, https://api.rubyonrails.org/classes/ActiveModel/SecurePassword/ClassMethods.html#method-i-has_secure_password|has_secure_password uses the password attribute, but you can customize this by specifying a different attribute via the attribute option. If you want to disable password reset functionality, you can pass reset_token: false to has_secure_password (it is enabled by default). Similarly, you can disable password confirmation validations by passing validations: false (validations are enabled by default).

#rubyonrails #ror #authentication #token #password

In recent versions of Rails, the default host for the test environment has changed from https://www.example.com|www.example.com to https://example.com|example.com. However, Capybara continues to use https://www.example.com|www.example.com in most cases, which can cause URL assertions in ActionMailer tests to fail when relying on the default settings. To resolve this inconsistency, you can explicitly set default_url_options[:host] to https://www.example.com|www.example.com in test.rb.
#RubyOnRails #ROR #ActionMailer #Capybara #TDD

SEO Best Practices:
• Meta titles should be between 50–60 characters long (including spaces).
• Meta descriptions should be between 120–160 characters (including spaces).
• Use a single H1 tag per page, followed by a clear and consistent hierarchy of H2 and H3 tags across all pages.
• All images should have meaningful alt tags for accessibility and SEO.
• Ensure there are no broken links; tools like Screaming Frog can help detect them.
• Include canonical tags to avoid duplicate content issues.
• Add social meta tags (Open Graph, Twitter Cards) for better link previews.
• The site should have a robots.txt file and a sitemap.xml for better crawling and indexing.
#SEOBestPractices #SearchEngineOptimization

In Rails, default_scope is a way to automatically apply a query condition to every query for a model.
When we define a default_scope, it always gets added unless we manually remove it.

Example:

default_scope { order(created_at: :asc) }

This ensures a consistent ordering across the app without needing to manually add .order(created_at: :asc) every time.
It's especially useful when displaying comments, messages, tasks, or anything that should appear in the order they were created.

Caution:
default_scope can sometimes be annoying if we want a different order temporarily.
In that case, we would need to call .unscope(:order) to remove it manually.

#rubyonrails

Instead of manually checking if a key exists in a hash, you can just say:

counts = Hash.new(0)

Now whenever you do:

counts[:apple] += 1

Ruby will assume counts[:apple] starts at 0, so no errors — just clean, readable code.

#ruby

Traits are reusable groups of attributes that we can apply to factories conditionally.
They help avoid duplication and let us customise factories based on different test scenarios.


We can define a trait inside a factory block using the trait keyword

FactoryBot.define do
  factory :user do
    name { "John Doe" }

    trait :admin do
      role { "admin" }
    end

    trait :with_profile_picture do
      after(:build) do |user|
        user.profile_picture.attach(
          io: File.open(Rails.root.join('spec/fixtures/files/test.jpg')),
          filename: 'test.jpg',
          content_type: 'image/jpeg'
        )
      end
    end
  end
end

And then we can use them in our specs. And traits can override any attribute defined in the factory

create(:user, :with_profile_picture)
create(:user, :admin, :with_profile_picture)

#CU6U0R822 #rspec

define_singleton_method dynamically adds a method to a single object instance without modifying the class itself. This is useful when you need custom behaviour for an individual object at runtime.

It only modifies the behaviour of a single object in memory at runtime. It does not persist any changes to the database or schema.

user = User.new(name: "Sibtain")

user.define_singleton_method(:greet) do
  "Hello, my name is #{name}!"
end

puts user.greet # => "Hello, my name is Sibtain"

#CU6U0R822

PostgreSQL's jsonb type stores structured JSON data efficiently. Unlike json, it's binary-optimized, supports indexing, and queries faster.
🔹 Why Use jsonb?
• Stores structured data in a single column.
• Faster queries (no reparsing needed).
• Supports indexing for quick lookups.
• Flexible schema—great for dynamic data.
• Allows key-value updates without rewriting the whole object.
• Removes duplicate keys automatically.
jsonb gives you NoSQL flexibility with SQL power! 🚀

#postgres

Aliasing in Ruby
Aliasing in Ruby helps to eliminate code repetition by providing an alternative name for an existing method, allowing it to be called in different ways without duplicating the logic.
For example,

module QuestionsHelper
  def can_modify_question?(question)
    !question.survey.has_answers?
  end

  alias_method :can_edit_question?, :can_modify_question?
  alias_method :can_delete_question?, :can_modify_question?
end

#ruby #aliasing