DEV Community: Georgy Yuriev

Rails 8 – New ActiveSupport Timezone Defaults

Georgy Yuriev — Fri, 12 Sep 2025 23:42:53 +0000

Rails 8 introduces a new default value for

ActiveSupport.to_time_preserves_timezone

# config/initializers/new_framework_defaults_8_0.rb
#
# Specifies whether `to_time` methods preserve the UTC offset of their receivers or preserve the timezone.
# If set to `:zone`, `to_time` methods will use the timezone of their receivers.
# If set to `:offset`, `to_time` methods will use the UTC offset.
# If `false`, `to_time` methods will convert to the local system UTC offset instead.
#
# Rails.application.config.active_support.to_time_preserves_timezone = :zone

It was not clear to me what this changes for my application or where problems might hide. So I figured it out.

require 'active_support/all'
Time.zone = 'America/New_York'

In the United States, daylight saving time begins on the second Sunday in March and ends on the first Sunday in November, with the time change occurring at 2:00 a.m. local time. I chose the borderline case - November 1st.

ActiveSupport.to_time_preserves_timezone = :offset

t = Time.zone.parse('1/Nov/2025 12:30:00').to_time
=> 2025-11-01 12:30:00 -0400

t.zone
=> nil

t + 1.day
=> 2025-11-02 12:30:00 -0400

Notice the lack of time zone information in the result object. The transition from daylight saving time was not completed.

ActiveSupport.to_time_preserves_timezone = :zone

t = Time.zone.parse('1/Nov/2025 12:30:00').to_time
=> 2025-11-01 12:30:00 -0400

t.zone
=> #<ActiveSupport::TimeZone:0x000000011c9aff20 @name="America/New_York", @tzinfo=#<TZInfo::DataTimezone: America/New_York>, @utc_offset=nil>

t + 1.day
=> 2025-11-02 12:30:00 -0500

But with the new Rails default (:zone), the to_time method returns an object with timezone information, which helps to correctly make calculations taking the daylight saving time transition into account.

Simple decorators with SimpleDelegator

Georgy Yuriev — Fri, 13 Jun 2025 23:39:10 +0000

Decorator is a powerful pattern that helps us keep our models clean while adding presentation logic. Today, I want to share my approach to implementing decorators in Ruby on Rails.

I was inspired by a great article:
Build a minimal decorator with Ruby in 30 minutes
by Rémi - @remi@ruby.social
Thanks to Ruby Weekly for sharing it!

What if we took a different approach? Let's solve this problem in reverse, like in the Tenet movie where time flows backwards 😈

Imagine we have

a Post model with a status enum column,
an Author model with first_name and last_name fields.

Let's create some decorators to enhance these models.

# app/decorators/post_decorator.rb

class PostDecorator < SimpleDelegator
  STATUS_COLORS = {
    published: :green,
    draft: :indigo
    archived: :gray,
    deleted: :red
  }.freeze

  def status_color = STATUS_COLORS[status.to_sym]
end

# app/decorators/author_decorator.rb

class AuthorDecorator < SimpleDelegator
  def full_name
    name = [first_name, last_name].compact.join(' ')
    name.presence || 'Guest'
  end
end

Now we can use it this way:

@posts = Post.all.map { PostDecorator.new(it) }

<%= AuthorDecorator.new(post.author).full_name %>

It adds so much boilerplate to the source code - I really dislike these wrappers. Let's clean this up adding method_missing method to all our models.

# app/models/application_record.rb

class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true

+  include Decoratable
end

# app/models/concerns/decoratable.rb

module Decoratable
  extend ActiveSupport::Concern

  def respond_to_missing?(method_name, ...)
    return false unless decorator_class

    decorator_class.instance_methods.include?(method_name)
  end

  def method_missing(method_name, ...)
    return super unless respond_to_missing?(method_name)

    decorated_instance.public_send(method_name, ...)
  end

  private

  def decorator_class
    @decorator_class ||= "#{model_name}Decorator".safe_constantize
  end

  def decorated_instance
    @decorated_instance ||= decorator_class.new(self)
  end
end

This will check if the method exists in the corresponding decorator before throwing an error, allowing us to use decorator methods as if they were defined in the models themselves!

- @posts = Post.all.map { PostDecorator.new(it) }
+ @posts = Post.all

- <%= AuthorDecorator.new(post.author).full_name %>
+ <%= post.author.full_name %>

This approach gives us the best of both worlds: clean models and convenient access to decorator methods. The method_missing implementation acts as a bridge between our models and decorators, making the code more maintainable and easier to work with.

Much cleaner now, right?

Ruby on Rails Flash notifications with Hotwire and ViewComponents

Georgy Yuriev — Sat, 24 May 2025 10:35:48 +0000

DEMO REPO

Every time we start out new Rails app, we need beautify default flash notifications and make it more comfortable to use. Let's incapsulate logic with ViewComponents and spice it up with dry-rb approach.

In the end of this article we will extend standard Rails approach of calling flash notifications by a couple of methods (with possibility of customization):

# add ability to show titles
flash[:alert] = 'notification text', 'WITH TITLE' 

# render within turbo_stream answers:
show_flash('Lorem ipsum')

# from anywhere:
Flash::Broadcast.call(user, 'Personal notification')

Gems

gem 'view_component'
gem 'view_component-contrib' # common patterns and practices
gem 'dry-initializer' # beautify the way of parameters handling
gem 'dry-types' # specify params types
gem 'inline_svg' # use helpers to render svg files

I like the way Vladimir Dementyev cook his view components, so we'll be using view_component-contrib meta-repository to get advantages of sidecar file structure and dry-way of defining parameters.

I handle my SVGs with inline_svg gem, which allows me to keep svg files in "app/assets/images/icons" folder and render it using simple helper.

You can skip those gems and use vanilla view components.

Also in this article I will use Tailwind for styling. Let's take Flowbite notification design.

JS libs

For animations and ability to close and remove from DOM our notifications we will use Stimulus Notification library.

Add dependencies

bin/importmap pin @stimulus-components/notification

// app/javascript/controllers/application.js
import { Application } from '@hotwired/stimulus'
import Notification from '@stimulus-components/notification' // ADD THIS 

const application = Application.start()
application.register('notification', Notification) // ADD THIS 

// ... the rest of the file

Create container

Add this wrapper to the bottom of <body>.

<%= tag.div id: :flash_container, class: 'z-50 fixed top-4 inset-x-4 sm:left-auto sm:w-full sm:max-w-sm md:right-8 md:top-8' do %>
  <% flash.each do |type, (message, title)| %>
    <%= render Flash::Component.new(message, type:, title:) %>
  <% end %>
<% end %>

Build component

Prepare generator and file structure for components (see "installation" in view_component-contrib documentation)

$ rails app:template LOCATION="https://railsbytes.com/script/zJosO5"

Interactive shell log:

Where do you want to store your view components? (default: app/frontend/components) ↵
Would you like to use dry-initializer in your component classes? (y/n) y
Do you use Stimulus? (y/n) y
Do you use TailwindCSS? (y/n) y
Would you like to create a custom generator for your setup? (y/n) y
Which template processor do you use? (1) ERB, (2) Haml, (3) Slim, (0) Other 1

Add this line to tell tailwind to watch our components directory:

// config/tailwind.config.js
module.exports = {
  content: [
    './app/frontend/components/**/*.{erb,html,rb,js}'
  ]
}

Generate our component

$ rails generate view_component Flash

# app/frontend/components/flash/component.rb
class Flash::Component < ApplicationViewComponent
  param :message, type: Types::Coercible::Array.of(Types::Coercible::String)
  option :type, type: Types::FlashType, default: -> { 'info' }
  option :title, type: Types::Coercible::String, optional: true

  COLORS = {
    info: 'text-blue-500 bg-blue-100 dark:bg-blue-800 dark:text-blue-200',
    success: 'text-green-500 bg-green-100 dark:bg-green-800 dark:text-green-200',
    warning: 'text-amber-500 bg-amber-100 dark:bg-amber-800 dark:text-amber-200',
    error: 'text-red-500 bg-red-100 dark:bg-red-800 dark:text-red-200'
  }.freeze

  ICONS = {
    info: :information_circle,
    success: :check_circle,
    warning: :exclamation_circle,
    error: :exclamation_circle
  }.freeze
end

Types of types ☉ ‿ ⚆

Notice the defenitions of types. Since Rails has only two types of flash (notice and alert) lets add some own types and cast the values to accepted ones.

# app/controllers/application_controller.rb
add_flash_types :error, :success

# lib/types.rb
module Types
  include Dry.Types()

  FLASH_TYPE_MAP = {
    info: :info,
    notice: :info,
    success: :success,
    alert: :warning,
    warning: :warning,
    fail: :error,
    error: :error
  }.freeze

  FlashType = Types::Coercible::Symbol
              .enum(*FLASH_TYPE_MAP.keys)
              .constructor { FLASH_TYPE_MAP[_1.to_sym] }
end

Also message is wrapped in array to be able to render e.g. @record.errors.full_messages as a several <p> tags inside notification.

Template

<%# app/frontend/components/flash/component.html.erb %>
<%= tag.div class: 'flex items-start w-full p-4 mb-2 text-gray-500 bg-white rounded-lg shadow dark:bg-gray-700 transition transform duration-200 hidden',
            data: {
              controller: :notification,
              notification_delay_value: 4000,
              transition_enter_from: 'opacity-0 translate-x-6',
              transition_enter_to: 'opacity-100 translate-x-0',
              transition_leave_from: 'opacity-100 translate-x-0',
              transition_leave_to: 'opacity-0 translate-x-6'
            } do %>
  <%= tag.div icon(ICONS[type], size: 24, variant: :solid),
              class: "#{COLORS[type]} inline-flex items-center justify-center flex-shrink-0 w-8 h-8 rounded-lg" %>

  <div class="ml-3 w-0 flex-1 pt-0.5">
    <%= tag.p title, class: 'text-sm font-medium text-gray-900 mb-1 dark:text-gray-100' %>
    <% message.each do |msg| %>
      <%= tag.p msg, class: 'text-sm text-gray-900 dark:text-gray-300' %>
    <% end %>
  </div>

  <div class="ml-4 flex-shrink-0 flex h-8 w-8">
    <%= button_tag icon(:x_mark, classes: 'w-5 h-5 stroke-2'),
                   data: { action: 'notification#hide' },
                   class: 'ms-auto bg-white text-gray-400 hover:text-gray-900 rounded-lg focus:ring-2 focus:ring-gray-500 p-1.5 hover:bg-gray-100 inline-flex items-center justify-center h-8 w-8 dark:focus:ring-gray-500 dark:text-gray-300 dark:hover:text-white dark:bg-gray-700 dark:hover:bg-gray-700' %>
  </div>
<% end %>

And also we used icon helper, here is the definition:

# app/helpers/application_helper.rb
def icon(name, options = {})
  options[:aria] = true
  options[:nocomment] = true
  options[:variant] ||= :outline
  options[:size] = options.fetch(:size, nil).to_s.presence
  options[:class] = options.fetch(:classes, nil)
  options[:style] << "stroke-width: #{options[:stroke]}" if options[:stroke].present?
  path = options.fetch(:path, "icons/#{options[:variant]}/#{name}.svg")
  icon = path
  inline_svg_tag(icon, options)
end

I have two styles of icons: outline and solid. Create two corresponding directories for it:

app/assets/images/icons/solid/
app/assets/images/icons/outline/

and put there your svg icons (heroicons e.g.) named accordingly with invocation parameters (we already defined them in Flash::Component::ICONS.values).

Make icon helper accessible in components:

# app/frontend/components/application_view_component.rb
delegate :icon, to: :helpers

That's it!

Advanced usage

Now we want to have the ability to render a flash as a part of TURBO_STREAM answers or even broadcast it from async jobs or service objects.

Let's write a couple of helpers for it.

Streaming from controllers

This is very simple, all you need is define handy helper:

# app/controllers/application_controller.rb
helper_method :show_flash

def show_flash(...)
  turbo_stream.append(:flash_container) do
    render Flash::Component.new(...)
  end
end

Now you can use it in your controller

respond_to do |format|
  format.turbo_stream do
    show_flash('Hello World', type: :success)
  end
end

Or even better take it out to your .turbo_stream.erb template:

<%= show_flash('I need to know', title: 'So Tell me something') %>

Broadcasting from anywhere

Assume you have generating report feature which runs asynchronously, and you want to notify the user that the generation of this report is complete. So user can surf the application, and upon receiving a notification, go to the reports section to download the generated file.

We need to have the ability to broadcast flash notification from our async job. Let's build the service object which sends a notification to a specific user.

Assume we use devise for authentication. We need to subscribe user for personal notifications channel. Add this line to app/views/layouts/application/_flash_container.html.erb

<%= turbo_stream_from dom_id(current_user, :flash_container) if user_signed_in? %>

Now create service object:

# app/services/application_service.rb
class ApplicationService
  extend Dry::Initializer

  class << self
    def call(...)
      new(...).call
    end
  end

  def call
    raise NotImplemetedError
  end
end

# app/services/flash/broadcast.rb
module Flash
  class Broadcast < ApplicationService
    param :user
    param :message
    param :options, optional: true, default: -> { {} }

    delegate :broadcast_append_to, to: Turbo::StreamsChannel
    delegate :dom_id, to: ActionView::RecordIdentifier
    delegate :render, to: ApplicationController

    def call
      broadcast_append_to(
        dom_id(user, :flash_container),
        target: :flash_container,
        html: render(Flash::Component.new(message, **options), layout: false)
      )
    end
  end
end

We pass user here and forward other parameters as "options" hash. Params validation already implemented in flash component, so we do not need to repeat it here, just "user", "message", and "some other stuff".

Thats all. Now we can go to rails console and play around with our service object (Flash::Broadcast.call(User.take, 'Hello')). Notifications will be displayed in "live mode".

Conclusion

We left the standard flash API untouched, so any plain old flash notifications will work as usual. But now we can customize notifications (set new types and titles). We can show flashes in turbo_stream responses without page reload and even send notifications asynchronously. Also we implemented a stack structure for them, so we can spam it as much as we want.

Hope this cookbook give you some ideas for your project!