turbo_chat 0.2.0 → 0.3.0

data/app/helpers/turbo_chat/application_helper/config_support.rb

@@ -2,8 +2,11 @@ module TurboChat
   module ApplicationHelper
     module ConfigSupport
       BOOLEAN_CHAT_SETTINGS = {
+        enable_mentions: true,
         mention_filter_exclude_self: true,
         mention_filter_hide_roles: true,
+        emit_typing_events: false,
+        emit_message_events: false,
         emit_mention_events: false,
         emit_invitation_events: false,
         emit_chat_lifecycle_events: false,
@@ -21,23 +24,27 @@ module TurboChat
         composer_add_files_display: false,
         composer_add_files_active: false,
         composer_microphone_display: false,
-        composer_microphone_active: false
+        composer_microphone_active: false,
+        signal_text_sheen: true,
+        show_timestamp: true,
+        show_role: false,
+        render_message_html: false
       }.freeze
 
       BOOLEAN_CHAT_SETTINGS.each do |setting, default|
-        define_method("chat_#{setting}?") do
-          chat_config_boolean(setting, default: default)
+        define_method("chat_#{setting}?") do |chat: nil|
+          chat_config_boolean(setting, default: default, chat: chat)
         end
       end
 
-      def chat_composer_placeholder_text
-        value = chat_config_value(:composer_placeholder_text, default: "start chatting")
+      def chat_composer_placeholder_text(chat: nil)
+        value = chat_config_value(:composer_placeholder_text, default: "start chatting", chat: chat)
         normalized = value.to_s.strip
         normalized.present? ? normalized : "start chatting"
       end
 
-      def chat_message_source_labels
-        configured = chat_config_value(:message_source_labels, default: {})
+      def chat_message_source_labels(chat: nil)
+        configured = chat_config_value(:message_source_labels, default: {}, chat: chat)
         return {} unless configured.respond_to?(:each_pair)
 
         configured.each_with_object({}) do |(source_key, label), normalized|
@@ -51,9 +58,9 @@ module TurboChat
         end
       end
 
-      def chat_message_source_label(source)
+      def chat_message_source_label(source, chat: nil)
         source_key = TurboChat::ChatMessage.normalize_source_key(source)
-        labels = chat_message_source_labels
+        labels = chat_message_source_labels(chat: chat)
         label = labels[source_key]
         return label if label.present?
 
@@ -66,11 +73,12 @@ module TurboChat
         source_key = TurboChat::ChatMessage.normalize_source_key(chat_message.source)
         return nil if source_key == TurboChat::ChatMessage::DEFAULT_SOURCE
 
-        chat_message_source_label(source_key)
+        message_chat = chat_message.respond_to?(:chat) ? chat_message.chat : nil
+        chat_message_source_label(source_key, chat: message_chat)
       end
 
-      def chat_style_key
-        raw_style = chat_config_value(:chat_style, default: "chat_style_bounded")
+      def chat_style_key(chat: nil)
+        raw_style = chat_config_value(:chat_style, default: "chat_style_bounded", chat: chat)
         normalized = raw_style.to_s.strip.downcase
 
         case normalized
@@ -81,16 +89,16 @@ module TurboChat
         end
       end
 
-      def chat_unbounded_style?
-        chat_style_key == "chat_style_unbounded"
+      def chat_unbounded_style?(chat: nil)
+        chat_style_key(chat: chat) == "chat_style_unbounded"
       end
 
-      def chat_shell_style_class
-        chat_unbounded_style? ? "chat-shell--style-unbounded" : "chat-shell--style-bounded"
+      def chat_shell_style_class(chat: nil)
+        chat_unbounded_style?(chat: chat) ? "chat-shell--style-unbounded" : "chat-shell--style-bounded"
       end
 
-      def chat_message_insert_position
-        raw_position = chat_config_value(:message_insert_position, default: "append_end")
+      def chat_message_insert_position(chat: nil)
+        raw_position = chat_config_value(:message_insert_position, default: "append_end", chat: chat)
         normalized = raw_position.to_s.strip.downcase
 
         case normalized
@@ -101,30 +109,32 @@ module TurboChat
         end
       end
 
-      def chat_message_append_start?
-        chat_message_insert_position == "append_start"
+      def chat_message_append_start?(chat: nil)
+        chat_message_insert_position(chat: chat) == "append_start"
       end
 
-      def chat_signal_ttl_seconds
-        value = chat_config_value(:signal_ttl_seconds, default: 60)
+      def chat_signal_ttl_seconds(chat: nil)
+        value = chat_config_value(:signal_ttl_seconds, default: 60, chat: chat)
         ttl = value.to_i
         ttl.positive? ? ttl : 60
       end
 
-      private
+      def chat_mode_key(chat)
+        TurboChat::Configuration.extract_chat_mode(chat) || :standard
+      end
 
-      def chat_config_value(method_name, default: nil)
-        configuration = TurboChat.configuration
-        return default unless configuration.respond_to?(method_name)
+      def chat_assistant_mode?(chat)
+        chat_mode_key(chat) == :assistant
+      end
+
+      private
 
-        configuration.public_send(method_name)
-      rescue NoMethodError, TypeError
-        default
+      def chat_config_value(method_name, default: nil, chat: nil)
+        TurboChat::Configuration.config_value(method_name, default: default, chat: chat)
       end
 
-      def chat_config_boolean(method_name, default:)
-        value = chat_config_value(method_name, default: default)
-        ActiveModel::Type::Boolean.new.cast(value)
+      def chat_config_boolean(method_name, default:, chat: nil)
+        TurboChat::Configuration.config_boolean(method_name, default: default, chat: chat)
       end
 
       def normalize_config_source_key(value)

data/app/helpers/turbo_chat/application_helper/mention_support.rb

@@ -10,8 +10,8 @@ module TurboChat
         allow_member_mentions = mention_permission.nil? ? true : mention_permission_allows?(mention_permission, :can_mention_members?)
         allow_all_mentions = mention_permission.nil? ? true : mention_permission_allows?(mention_permission, :can_mention_all?)
         allow_role_mentions = mention_permission.nil? ? true : mention_permission_allows?(mention_permission, :can_mention_roles?)
-        allow_role_mentions &&= !chat_mention_filter_hide_roles?
-        exclude_self_mentions = chat_mention_filter_exclude_self?
+        allow_role_mentions &&= !chat_mention_filter_hide_roles?(chat: chat)
+        exclude_self_mentions = chat_mention_filter_exclude_self?(chat: chat)
         viewer_participant = mention_viewer_participant(permission: mention_permission)
 
         options = []
@@ -73,7 +73,7 @@ module TurboChat
       end
 
       def chat_mentions_enabled_for?(chat:, permission: nil)
-        return false unless TurboChat.configuration.enable_mentions
+        return false unless chat_enable_mentions?(chat: chat)
 
         mention_permission = permission || mention_permission_for(chat)
         return true if mention_permission.nil?

data/app/helpers/turbo_chat/application_helper/message_rendering.rb

@@ -16,9 +16,9 @@ module TurboChat
         "--chat-bubble-bg: #{hex_color}; --chat-bubble-border: #{hex_color};"
       end
 
-      def chat_mentions_container_inline_style
-        hex_color = normalize_hex_color(chat_config_value(:mention_mark_hex_color)) ||
-                    normalize_hex_color(chat_config_value(:mention_highlight_hex_color))
+      def chat_mentions_container_inline_style(chat: nil)
+        hex_color = normalize_hex_color(chat_config_value(:mention_mark_hex_color, chat: chat)) ||
+                    normalize_hex_color(chat_config_value(:mention_highlight_hex_color, chat: chat))
         return nil if hex_color.blank?
 
         mention_mark_background = hex_color_with_alpha(hex_color, alpha: 0.22)
@@ -26,21 +26,25 @@ module TurboChat
       end
 
       def render_chat_message_body(chat_message)
+        chat = chat_message.respond_to?(:chat) ? chat_message.chat : nil
         body = chat_message.body.to_s
         # html_safe is safe here: decorate_plain_message_text guarantees the body
         # is html_escaped before any markup injection (see method comment above).
-        return content_tag(:p, decorate_plain_message_text(body).html_safe, class: "chat-body") unless TurboChat.configuration.render_message_html
+        unless chat_render_message_html?(chat: chat)
+          return content_tag(:p, decorate_plain_message_text(body, chat: chat).html_safe, class: "chat-body")
+        end
 
         sanitized_html = sanitize(
           body,
-          tags: Array(TurboChat.configuration.message_html_tags),
-          attributes: Array(TurboChat.configuration.message_html_attributes)
+          tags: Array(chat_config_value(:message_html_tags, default: [], chat: chat)),
+          attributes: Array(chat_config_value(:message_html_attributes, default: [], chat: chat))
         )
         content_tag(:div, sanitized_html, class: "chat-body")
       end
 
       def chat_message_mention_tokens(chat_message)
-        return [] unless TurboChat.configuration.enable_mentions && chat_message.present?
+        chat = chat_message.respond_to?(:chat) ? chat_message.chat : nil
+        return [] unless chat_enable_mentions?(chat: chat) && chat_message.present?
 
         chat_message.body.to_s.scan(MENTION_PATTERN).uniq
       end
@@ -48,7 +52,8 @@ module TurboChat
       private
 
       def resolve_custom_message_css_classes(chat_message:, own_message:)
-        resolver = TurboChat.configuration.message_css_class_resolver
+        message_chat = chat_message.respond_to?(:chat) ? chat_message.chat : nil
+        resolver = chat_config_value(:message_css_class_resolver, default: nil, chat: message_chat)
         return [] unless resolver.respond_to?(:call)
 
         classes = call_message_css_class_resolver(resolver, chat_message: chat_message, own_message: own_message)
@@ -58,15 +63,21 @@ module TurboChat
       end
 
       def resolve_message_hex_color(chat_message:, own_message:)
+        message_chat = chat_message.respond_to?(:chat) ? chat_message.chat : nil
         role_color = resolve_role_message_hex_color(chat_message: chat_message, own_message: own_message)
         return role_color if role_color.present?
 
-        base_color = own_message ? TurboChat.configuration.own_message_hex_color : TurboChat.configuration.other_message_hex_color
+        base_color = if own_message
+                       chat_config_value(:own_message_hex_color, default: nil, chat: message_chat)
+                     else
+                       chat_config_value(:other_message_hex_color, default: nil, chat: message_chat)
+                     end
         normalize_hex_color(base_color)
       end
 
       def resolve_role_message_hex_color(chat_message:, own_message:)
-        role_colors = TurboChat.configuration.role_message_hex_colors
+        message_chat = chat_message.respond_to?(:chat) ? chat_message.chat : nil
+        role_colors = chat_config_value(:role_message_hex_colors, default: {}, chat: message_chat)
         return nil unless role_colors.is_a?(Hash)
 
         role_key = chat_message_role_key(chat_message)
@@ -112,10 +123,10 @@ module TurboChat
       # The result is safe to mark as html_safe because no raw user content
       # reaches the output unescaped. Any change to this pipeline MUST
       # preserve html_escape as the first step.
-      def decorate_plain_message_text(body)
+      def decorate_plain_message_text(body, chat: nil)
         formatted = ERB::Util.html_escape(body.to_s)
-        formatted = apply_emoji_aliases(formatted) if TurboChat.configuration.enable_emoji_aliases
-        formatted = apply_mention_highlights(formatted) if TurboChat.configuration.enable_mentions
+        formatted = apply_emoji_aliases(formatted) if chat_config_boolean(:enable_emoji_aliases, default: true, chat: chat)
+        formatted = apply_mention_highlights(formatted) if chat_enable_mentions?(chat: chat)
         formatted.gsub(/\r\n?|\n/, "<br>")
       end
 

data/app/models/turbo_chat/chat.rb

@@ -1,5 +1,7 @@
 module TurboChat
   class Chat < ApplicationRecord
+    enum :chat_mode, { standard: 0, assistant: 1 }, prefix: true, default: :standard
+
     has_many :chat_memberships,
              class_name: "TurboChat::ChatMembership",
              dependent: :destroy,
@@ -34,29 +36,39 @@ module TurboChat
     }
 
     def active_signals(window: nil)
-      cutoff = Time.current - self.class.signal_window_seconds(window)
+      cutoff = Time.current - self.class.signal_window_seconds(window, chat: self)
+
       latest_message_at = chat_messages
                           .message
                           .where("created_at >= ?", cutoff)
                           .group(:participant_type, :participant_id)
                           .maximum(:created_at)
 
-      recent = chat_messages.signal.where("created_at >= ?", cutoff).ordered.reverse
-      seen = {}
-      recent.each_with_object([]) do |message, output|
-        participant_key = [message.participant_type, message.participant_id]
-        last_message_time = latest_message_at[participant_key]
-        next if last_message_time && last_message_time >= message.created_at
-        next if seen[participant_key]
-
-        output << message
-        seen[participant_key] = true
-      end.reverse
+      latest_signal_ids = chat_messages.signal
+                          .where("created_at >= ?", cutoff)
+                          .group(:participant_type, :participant_id)
+                          .maximum(:id)
+                          .values
+
+      return [] if latest_signal_ids.empty?
+
+      signals = chat_messages.signal.where(id: latest_signal_ids).ordered
+
+      signals.reject do |signal|
+        participant_key = [signal.participant_type, signal.participant_id]
+        last_msg_time = latest_message_at[participant_key]
+        last_msg_time && last_msg_time >= signal.created_at
+      end
     end
 
-    def visible_messages(limit: TurboChat.configuration.message_history_limit)
+    def visible_messages(limit: :configured)
       relation = chat_messages.timeline
-      normalized_limit = normalize_message_limit(limit)
+      configured_limit = if limit == :configured
+                           TurboChat::Configuration.config_value(:message_history_limit, default: 200, chat: self)
+                         else
+                           limit
+                         end
+      normalized_limit = normalize_message_limit(configured_limit)
       if normalized_limit
         recent_ids = relation.reorder(created_at: :desc, id: :desc).limit(normalized_limit).select(:id)
         relation = relation.where(id: recent_ids)
@@ -69,6 +81,14 @@ module TurboChat
       @membership_lookup ||= chat_memberships.active.index_by { |m| [m.participant_type, m.participant_id] }
     end
 
+    def find_active_membership(participant)
+      if instance_variable_defined?(:@membership_lookup)
+        membership_lookup[[participant.class.base_class.name, participant.id]]
+      else
+        chat_memberships.active.find_by(participant: participant)
+      end
+    end
+
     def last_message_at
       chat_messages.message.maximum(:created_at)
     end
@@ -77,7 +97,7 @@ module TurboChat
       message_time = last_message_at
       return false if message_time.nil?
 
-      message_time >= at - self.class.activity_window_seconds(window)
+      message_time >= at - self.class.activity_window_seconds(window, chat: self)
     end
 
     def inactive?(window: nil, at: Time.current)
@@ -100,18 +120,21 @@ module TurboChat
       update!(closed_at: nil)
     end
 
-    def self.activity_window_seconds(window = nil)
-      value = window.nil? ? TurboChat.configuration.active_chat_window : window
+    def self.activity_window_seconds(window = nil, chat: nil)
+      value = if window.nil?
+                TurboChat::Configuration.config_value(:active_chat_window, default: 5.minutes, chat: chat)
+              else
+                window
+              end
       seconds = value.to_i
       return seconds if seconds.positive?
 
       raise ArgumentError, "active chat window must be a positive duration"
     end
 
-    def self.signal_window_seconds(window = nil)
+    def self.signal_window_seconds(window = nil, chat: nil)
       value = if window.nil?
-                configuration = TurboChat.configuration
-                configuration.respond_to?(:signal_ttl_seconds) ? configuration.signal_ttl_seconds : 60
+                TurboChat::Configuration.config_value(:signal_ttl_seconds, default: 60, chat: chat)
               else
                 window
               end

data/app/models/turbo_chat/chat_membership.rb

@@ -108,7 +108,7 @@ module TurboChat
     def enforce_chat_participant_limit
       return if chat.nil?
 
-      limit = TurboChat.configuration.max_chat_participants
+      limit = TurboChat::Configuration.config_value(:max_chat_participants, default: nil, chat: chat)
       return if limit.nil?
 
       limit = limit.to_i

data/app/models/turbo_chat/chat_message/blocked_words_moderation.rb

@@ -37,15 +37,14 @@ module TurboChat
 
       def scramble_word(word)
         source = word.to_s
-        characters = source.chars
-        return source if characters.length < 2
+        return source if source.length < 2
 
-        scrambled = characters.shuffle
-        if scrambled == characters && characters.uniq.length > 1
-          scrambled = characters.rotate(1)
-        end
+        chars = scramble_chars_from_configuration
+        source.chars.map { chars.sample }.join
+      end
 
-        scrambled.join
+      def scramble_chars_from_configuration
+        Array(TurboChat.configuration.effective_blocked_words_scramble_chars).presence || TurboChat::Configuration::DEFAULT_BLOCKED_WORDS_SCRAMBLE_CHARS
       end
 
       def blocked_word_pattern(word)
@@ -53,21 +52,11 @@ module TurboChat
       end
 
       def blocked_words_from_configuration
-        configuration = TurboChat.configuration
-        return [] unless configuration.respond_to?(:effective_blocked_words)
-
-        Array(configuration.effective_blocked_words)
-      rescue NoMethodError, TypeError
-        []
+        Array(TurboChat.configuration.effective_blocked_words)
       end
 
       def blocked_words_action_from_configuration
-        configuration = TurboChat.configuration
-        return "reject" unless configuration.respond_to?(:effective_blocked_words_action)
-
-        configuration.effective_blocked_words_action.to_s
-      rescue NoMethodError, TypeError
-        "reject"
+        TurboChat.configuration.effective_blocked_words_action.to_s
       end
 
       def emit_blocked_words_event(name, blocked_words:, action:, original_body: nil, moderated_body: nil)
@@ -88,12 +77,7 @@ module TurboChat
       end
 
       def blocked_words_events_enabled?
-        configuration = TurboChat.configuration
-        return false unless configuration.respond_to?(:emit_blocked_words_events)
-
-        ActiveModel::Type::Boolean.new.cast(configuration.emit_blocked_words_events)
-      rescue NoMethodError, TypeError
-        false
+        TurboChat::Configuration.config_boolean(:emit_blocked_words_events, default: false, chat: chat)
       end
 
       def scramble_blocked_words_with_event!(blocked_words, matches:, action:)

data/app/models/turbo_chat/chat_message/body_length_validation.rb

@@ -6,7 +6,7 @@ module TurboChat
       private
 
       def body_within_max_length
-        configured_limit = TurboChat.configuration.max_message_length
+        configured_limit = TurboChat::Configuration.config_value(:max_message_length, default: 1000, chat: chat)
         return if configured_limit.nil?
 
         limit = configured_limit.to_i

data/app/models/turbo_chat/chat_message/broadcasting.rb

@@ -76,12 +76,8 @@ module TurboChat
       end
 
       def append_start_position?
-        configuration = TurboChat.configuration
-        value = configuration.respond_to?(:message_insert_position) ? configuration.message_insert_position : "append_end"
-        normalized = value.to_s.strip.downcase
-        %w[append_start start prepend].include?(normalized)
-      rescue NoMethodError, TypeError
-        false
+        value = TurboChat::Configuration.config_value(:message_insert_position, default: "append_end", chat: chat).to_s.strip.downcase
+        %w[append_start start prepend].include?(value)
       end
     end
   end

data/app/models/turbo_chat/chat_message/formatting.rb

@@ -34,7 +34,7 @@ module TurboChat
 
         role = membership.effective_role_key
 
-        formatter = TurboChat.configuration.role_formatter
+        formatter = TurboChat::Configuration.config_value(:role_formatter, default: nil, chat: chat)
         formatted = apply_formatter(formatter, role, self)
         return formatted if formatted.present?
 
@@ -46,15 +46,11 @@ module TurboChat
       def participant_membership
         return @participant_membership if instance_variable_defined?(:@participant_membership)
 
-        @participant_membership = if chat.respond_to?(:membership_lookup) && chat.instance_variable_defined?(:@membership_lookup)
-                                    chat.membership_lookup[[participant_type, participant_id]]
-                                  else
-                                    chat.chat_memberships.active.find_by(participant: participant)
-                                  end
+        @participant_membership = chat.find_active_membership(participant)
       end
 
       def formatted_time_for(timestamp)
-        formatter = TurboChat.configuration.timestamp_formatter
+        formatter = TurboChat::Configuration.config_value(:timestamp_formatter, default: nil, chat: chat)
         formatted = apply_formatter(formatter, timestamp, self)
         return formatted if formatted.present?
 

data/app/models/turbo_chat/chat_message/mention_validation.rb

@@ -6,7 +6,7 @@ module TurboChat
       private
 
       def mentions_allowed_for_participant
-        return unless TurboChat.configuration.enable_mentions
+        return unless TurboChat::Configuration.config_boolean(:enable_mentions, default: true, chat: chat)
 
         mentions = mention_tokens
         return if mentions.empty?

data/app/models/turbo_chat/chat_message/signals.rb

@@ -62,7 +62,7 @@ module TurboChat
       end
 
       def replace_participant_signals_on_submit
-        return unless TurboChat.configuration.replace_signals_on_message_submit
+        return unless TurboChat::Configuration.config_boolean(:replace_signals_on_message_submit, default: false, chat: chat)
         return if chat_id.blank? || participant_type.blank? || participant_id.blank?
 
         self.class.where(

data/app/models/turbo_chat/chat_message.rb

@@ -81,7 +81,7 @@ module TurboChat
       end
 
       def create_membership_system_message!(chat:, actor:, event:, subject: nil)
-        return nil unless system_messages_enabled?
+        return nil unless system_messages_enabled?(chat)
         return nil if chat.nil? || actor.nil?
 
         normalized_event = event.to_s.to_sym
@@ -93,13 +93,8 @@ module TurboChat
         create!(chat: chat, participant: actor, kind: :system, body: body)
       end
 
-      def system_messages_enabled?
-        configuration = TurboChat.configuration
-        return true unless configuration.respond_to?(:system_messages)
-
-        ActiveModel::Type::Boolean.new.cast(configuration.system_messages)
-      rescue NoMethodError, TypeError
-        true
+      def system_messages_enabled?(chat = nil)
+        TurboChat::Configuration.config_boolean(:system_messages, default: true, chat: chat)
       end
 
       private

data/app/views/turbo_chat/chat_messages/_form.html.erb

@@ -7,23 +7,23 @@
 <% current_participant = local_assigns[:current_participant] || current_chat_participant %>
 <% current_participant_type = current_participant.class.base_class.name %>
 <% current_participant_id = current_participant.id %>
-<% show_add_files_button = chat_composer_add_files_display? %>
-<% add_files_button_active = chat_composer_add_files_active? %>
-<% show_microphone_button = chat_composer_microphone_display? %>
-<% microphone_button_active = chat_composer_microphone_active? %>
+<% show_add_files_button = chat_composer_add_files_display?(chat: chat) %>
+<% add_files_button_active = chat_composer_add_files_active?(chat: chat) %>
+<% show_microphone_button = chat_composer_microphone_display?(chat: chat) %>
+<% microphone_button_active = chat_composer_microphone_active?(chat: chat) %>
 <% composer_shell_classes = ["chat-composer-shell"] %>
 <% composer_shell_classes << "chat-composer-shell--no-leading-tool" unless show_add_files_button %>
 <div class="chat-composer"
      data-chat-composer
      data-chat-id="<%= chat.id %>"
-     data-chat-emit-typing-events="<%= TurboChat.configuration.emit_typing_events %>"
-     data-chat-emit-message-events="<%= TurboChat.configuration.emit_message_events %>"
+     data-chat-emit-typing-events="<%= chat_emit_typing_events?(chat: chat) %>"
+     data-chat-emit-message-events="<%= chat_emit_message_events?(chat: chat) %>"
      data-chat-enable-mentions="<%= mentions_enabled %>"
      data-chat-can-mention-members="<%= can_mention_members %>"
      data-chat-can-mention-all="<%= can_mention_all %>"
      data-chat-can-mention-roles="<%= can_mention_roles %>"
-     data-chat-mention-filter-exclude-self="<%= chat_mention_filter_exclude_self? %>"
-     data-chat-mention-filter-hide-roles="<%= chat_mention_filter_hide_roles? %>"
+     data-chat-mention-filter-exclude-self="<%= chat_mention_filter_exclude_self?(chat: chat) %>"
+     data-chat-mention-filter-hide-roles="<%= chat_mention_filter_hide_roles?(chat: chat) %>"
      data-chat-self-participant-type="<%= current_participant_type %>"
      data-chat-self-participant-id="<%= current_participant_id %>"
      data-chat-mention-options="<%= json_escape(mention_options.to_json) %>">
@@ -41,7 +41,7 @@
                       rows: 1,
                       required: true,
                       class: "chat-composer-input",
-                      placeholder: chat_composer_placeholder_text,
+                      placeholder: chat_composer_placeholder_text(chat: chat),
                       data: { chat_message_input: true } %>
       <% if show_microphone_button %>
         <button type="button"

data/app/views/turbo_chat/chat_messages/_message.html.erb

@@ -1,6 +1,6 @@
 <% own_message = own_chat_message?(chat_message) %>
-<% show_timestamp = TurboChat.configuration.show_timestamp %>
-<% show_role = TurboChat.configuration.show_role %>
+<% show_timestamp = chat_show_timestamp?(chat: chat_message.chat) %>
+<% show_role = chat_show_role?(chat: chat_message.chat) %>
 <% role_label = show_role ? chat_message.formatted_participant_role : nil %>
 <% source_badge_label = chat_message_source_badge_label(chat_message) %>
 <% edited_message = chat_message.respond_to?(:edited?) && chat_message.edited? %>

data/app/views/turbo_chat/chat_messages/_signals.html.erb

@@ -1,11 +1,13 @@
 <% show_self_signals = if respond_to?(:chat_show_self_signals?, true)
-                         chat_show_self_signals?
-                       else
-                         configuration = TurboChat.configuration
-                         value = configuration.respond_to?(:show_self_signals) ? configuration.show_self_signals : false
-                         ActiveModel::Type::Boolean.new.cast(value)
-                       end %>
-<% signal_text_sheen_enabled = ActiveModel::Type::Boolean.new.cast(TurboChat.configuration.signal_text_sheen) %>
+                       chat_show_self_signals?(chat: chat)
+                     else
+                       TurboChat::Configuration.config_boolean(:show_self_signals, default: false, chat: chat)
+                     end %>
+<% signal_text_sheen_enabled = if respond_to?(:chat_signal_text_sheen?, true)
+                                 chat_signal_text_sheen?(chat: chat)
+                               else
+                                 TurboChat::Configuration.config_boolean(:signal_text_sheen, default: true, chat: chat)
+                               end %>
 <% current_participant = respond_to?(:current_chat_participant, true) ? current_chat_participant : nil %>
 <% current_participant_type = current_participant&.class&.base_class&.name %>
 <% current_participant_id = current_participant&.id %>
@@ -29,12 +31,8 @@
                        signal_message.signal_type.to_s
                      end %>
     <strong><%= signal_message.participant_display_name %></strong>
-    <span class="chat-signal-text<%= " chat-signal-text--sheen" if signal_text_sheen_enabled %>">
-      <% if signal_text_sheen_enabled %>
-        <span class="chat-signal-text-sheen"><%= signal_text %></span>
-      <% else %>
-        <%= signal_text %>
-      <% end %>
+    <span class="chat-signal-text<%= " chat-signal-text--pulse" if signal_text_sheen_enabled %>">
+      <%= signal_text %>
     </span>
   </div>
 <% end %>

data/app/views/turbo_chat/chat_messages/_system.html.erb

@@ -1,6 +1,6 @@
 <article id="<%= dom_id(chat_message) %>" class="chat-system-message">
   <p class="chat-system-message__body"><%= chat_message.body %></p>
-  <% if TurboChat.configuration.show_timestamp %>
+  <% if chat_show_timestamp?(chat: chat_message.chat) %>
     <time class="chat-system-message__timestamp" datetime="<%= chat_message.created_at.iso8601 %>">
       <%= chat_message.formatted_timestamp %>
     </time>

data/app/views/turbo_chat/chats/_invite_form.html.erb

@@ -24,5 +24,5 @@
       Type at least 2 characters.
     </p>
   </div>
-  <%= f.submit "Invite", class: "chat-btn chat-btn--small" %>
+  <%= f.submit "Invite", class: "chat-btn chat-btn--small", data: { chat_invite_submit: true } %>
 <% end %>