Best Practices for Managing Gems in Your Rails Application

Screening for new Gems

Including quality gems can drastically reduce development time.

However, suboptimal choices can lead to maintenance overhead and additional costs.

Efficient Gem Evaluation

Before adopting a gem, verify if its functionality aligns with your needs.

Avoid those that offer excessive features beyond your requirements as they can bloat your application unnecessarily.

Assessing Community Support

Check the gem’s repository for activity indicators:

• Commit frequency: Frequent updates suggest active maintenance.
• Issue resolution: Quick and effective issue resolutions indicate strong support.
• Stars and Forks: High numbers can imply reliability and community trust.

Reviewing Code Quality

Examine the source code when possible:

• Code clarity: Well-structured and commented code reduces integration and maintenance efforts.
• Test coverage: Comprehensive tests reflect stability and ease future updates.

Practical Usage Check

Search for blog posts or tutorials detailing others’ experiences with the gem. Presence of detailed documentation and positive feedback are good signs.

Conversely, multiple unresolved issues or compatibility problems are red flags.

Selecting a Gem: The TAM Method

When picking a gem, confirm it includes an automated test suite.

This is not just about ensuring the current functionality, but also about maintaining future stability.

A gem without tests risks your application’s reliability.

T: Tests

Ensure the gem includes a robust automated test suite to maintain future stability and reduce maintenance overhead.

A: Activity

Check the gem’s repository for recent commits, issues, and pull requests.

Active maintenance and community engagement indicate strong support and quick adaptation to new issues or Rails versions.

M: Maturity

Evaluate the gem’s age and version history.

Stability often correlates with maturity.

Mature gems provide reliability and less risk for major issues, thereby reducing the total cost of ownership.

Gem modifications

Modify third-party code carefully to avoid maintenance headaches. Here are strategies for better managing these changes:

Monkey Patching

Monkey patching allows adaptation of third-party code by reopening classes or modules to alter their behavior runtime, without touching the original source.

# lib/validatable_extensions.rb
module Validatable
  class ValidatesNumericalityOf < ValidationBase
    def valid?(instance)
      # 1. Copy paste original code from the git repo
      # 2. Modify the lines that you need

      value = value_for(instance)
      return true if allow_nil && value.nil?

      return true if allow_blank && value.blank?

      value = value.to_s
      # EXAMPLE: Here we could modify the regexp for our use case.
      regex = self.only_integer ? /\A[+-]?\d+\Z/ : /\A[+-]?\d*\.{0,1}\d+$/
      not (value =~ regex).nil?
    end
  end
end

Forking

If a monkey patch corrects a significant issue or enhances a library sensibly, consider forking the project on platforms like GitHub.

# Gemfile
gem 'validatable', git: 'git://github.com/yourusername/validatable.git'

Cleaning and Maintaining your Gemfile

Maintaining an optimized Gemfile is crucial for application health and performance.

Identifying Unused Gems

Regularly check your Gemfile and cross-reference usage throughout your application using tools like bundler-audit or gem_unused.

Updating and Removing Gems

Keep your gems updated and remove unused or irrelevant gems to enhance security and application performance.

bundle update
bundle install

By following these practices, you can enhance your Rails applications through careful gem selection and maintenance, ensuring high performance and reducing potential future costs.

Gem OCD

Not a critical comment for company profits, but I have strong OCD regarding gemfiles. Add:

• Description
• Consistent use of quotes
• Always check your versions

# Gemfile

# Ruby on Rails is a full-stack web framework optimized for programmer happiness and sustainable productivity. It encourages beautiful code by favoring convention over configuration.
gem 'rails', '~> 7.1', '>= 7.1.3.2'

Final words: Share your gems

We are not the JS community, we love our gems.

Please share them in the r/rails, twiter, youtube, etc.

You will be surprise how much love and great advice you will receive.

The more you build, the more you know which gems to use, and you will find yourself quickly typing the name of the gem in your gemfile.

That’s the level of expertise you should be aiming for.

Related posts