Managing application settings in a Ruby on Rails application can be super important for keeping things flexible and easy to configure. Imagine this: you’ve got an amazing Rails app, but you’re tired of hardcoding settings directly into it. Sounds like a nightmare for maintenance, right? That’s where the rails-settings gem comes into the picture. It lets you store and manage global settings right in your database. Let’s get into it and see how this can streamline your app’s configuration.

First off, why should you even bother with a settings gem? Think about it—hardcoding settings make your app rigid and tough to tweak. It’s like having a car where you can’t adjust the seat or mirrors. By storing settings in a database, you get the luxury of tweaking configurations on the fly, without touching your codebase. Plus, you can have different settings for different environments like development, testing, and production.

So, to start using this nifty rails-settings gem, you need to add it to your Gemfile and run the bundle command. It’s pretty straightforward.

gem 'ledermann-rails-settings'

Then, you run:

bundle

After installing it, you’ll need to generate and run a migration to create the necessary database table.

rails g rails_settings:migration
rake db:migrate

Easy peasy!

Now, defining settings is where this gem shines. You can do this right in your models or use a separate settings model. Let’s check out an example for a User model.

class User < ActiveRecord::Base
  has_settings do |s|
    s.key :dashboard, defaults: { theme: 'blue', view: 'monthly', filter: false }
    s.key :calendar, defaults: { scope: 'company' }
  end
end

Here, you’ve got two settings: dashboard and calendar. Each comes with default values. Super handy, right?

Setting and getting these values is a breeze. Once they’re defined, you can set and get them like this:

user = User.find(1)

user.settings(:dashboard).theme = 'black'
user.settings(:calendar).scope = 'all'
user.save!

Later on, to get those values:

theme = user.settings(:dashboard).theme # => 'black'
scope = user.settings(:calendar).scope # => 'all'

Even better, you can update multiple settings at once:

user.settings(:dashboard).update theme: 'black', view: 'weekly'
user.settings(:calendar).update scope: 'all', display: 'daily'

Deleting settings is just as simple. Set a setting to nil and save.

user.settings(:dashboard).theme = nil
user.settings(:dashboard).save!

And guess what? This gem also supports scopes. You can query users based on their settings, making life so much easier.

User.with_settings                    # find users with any setting
User.without_settings                 # find users without settings
User.with_settings_for(:calendar)     # find users with a 'calendar' setting
User.without_settings_for(:calendar)  # find users without a 'calendar' setting

Talking about performance, the gem allows eager loading of setting objects when querying multiple users.

User.includes(:setting_objects)

Now, what if you need custom validation? No problem! You can define a custom class that inherits from RailsSettings::SettingObject.

class ProjectSettingObject < RailsSettings::SettingObject
  validate do
    unless self.owner_name.present? && self.owner_name.is_a?(String)
      errors.add(:base, "Owner name is missing")
    end
  end
end

class Project < ActiveRecord::Base
  has_settings :info, class_name: 'ProjectSettingObject'
end

Sometimes, you need persistent settings separately for the same models. Use the persistent option for that.

module UserDashboardConcern
  extend ActiveSupport::Concern

  included do
    has_settings persistent: true do |s|
      s.key :dashboard
    end
  end
end

class User < ActiveRecord::Base
  include UserDashboardConcern

  has_settings persistent: true do |s|
    s.key :calendar
  end
end

But wait, there’s more! While ledermann-rails-settings is awesome, there are other gems out there like rails-settings-cached and rails-settings-manager. They also manage global settings but come with different features and requirements.

This gem is compatible with Rails 6.1 and newer versions, including Rails 7.0, and it requires Ruby 2.7 or newer. So if you’re on an updated tech stack, you’re good to go!

Managing application settings in Rails doesn’t have to be a headache. By using the rails-settings gem, you’re adding a flexible, easy-to-use layer to your app’s configuration. Whether you’re dealing with simple key-value pairs or more complex settings, this gem has got your back. So go ahead, give it a whirl, and make your Rails app more manageable and scalable.

There it is, your guide to handling application settings in Ruby on Rails with the rails-settings gem. Happy coding!