turbo_chat 0.1.0

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

@@ -0,0 +1,120 @@
+module ChatGem
+  class ChatMessage
+    module BlockedWordsModeration
+      extend ActiveSupport::Concern
+
+      private
+
+      def apply_blocked_words_moderation
+        blocked_words = blocked_words_from_configuration
+        return if blocked_words.empty?
+
+        matches = blocked_words_in_body(blocked_words)
+        return if matches.empty?
+
+        action = blocked_words_action_from_configuration
+        emit_blocked_words_event(
+          "chat_gem.blocked_words.detected",
+          blocked_words: matches,
+          action: action
+        )
+        if action == "scramble"
+          original_body = body.to_s.dup
+          scramble_blocked_words!(blocked_words)
+          emit_blocked_words_event(
+            "chat_gem.blocked_words.scrambled",
+            blocked_words: matches,
+            action: action,
+            original_body: original_body,
+            moderated_body: body.to_s
+          )
+          return
+        end
+
+        errors.add(:body, "contains blocked language")
+        emit_blocked_words_event(
+          "chat_gem.blocked_words.rejected",
+          blocked_words: matches,
+          action: action
+        )
+      end
+
+      def blocked_words_in_body(blocked_words)
+        blocked_words.select { |word| blocked_word_pattern(word).match?(body.to_s) }
+      end
+
+      def scramble_blocked_words!(blocked_words)
+        moderated_body = body.to_s.dup
+
+        blocked_words.each do |word|
+          moderated_body.gsub!(blocked_word_pattern(word)) do |match|
+            scramble_word(match)
+          end
+        end
+
+        self.body = moderated_body
+      end
+
+      def scramble_word(word)
+        source = word.to_s
+        characters = source.chars
+        return source if characters.length < 2
+
+        scrambled = characters.shuffle
+        if scrambled == characters && characters.uniq.length > 1
+          scrambled = characters.rotate(1)
+        end
+
+        scrambled.join
+      end
+
+      def blocked_word_pattern(word)
+        /(?<![[:alnum:]_])#{Regexp.escape(word)}(?![[:alnum:]_])/i
+      end
+
+      def blocked_words_from_configuration
+        configuration = ChatGem.configuration
+        return [] unless configuration.respond_to?(:effective_blocked_words)
+
+        Array(configuration.effective_blocked_words)
+      rescue StandardError
+        []
+      end
+
+      def blocked_words_action_from_configuration
+        configuration = ChatGem.configuration
+        return "reject" unless configuration.respond_to?(:effective_blocked_words_action)
+
+        configuration.effective_blocked_words_action.to_s
+      rescue StandardError
+        "reject"
+      end
+
+      def emit_blocked_words_event(name, blocked_words:, action:, original_body: nil, moderated_body: nil)
+        return unless blocked_words_events_enabled?
+        return unless defined?(ActiveSupport::Notifications)
+
+        payload = {
+          chat_id: chat_id,
+          message_id: id,
+          participant_type: participant_type,
+          participant_id: participant_id,
+          blocked_words: Array(blocked_words).map(&:to_s),
+          action: action.to_s
+        }
+        payload[:original_body] = original_body if original_body.present?
+        payload[:moderated_body] = moderated_body if moderated_body.present?
+        ActiveSupport::Notifications.instrument(name, payload)
+      end
+
+      def blocked_words_events_enabled?
+        configuration = ChatGem.configuration
+        return false unless configuration.respond_to?(:emit_blocked_words_events)
+
+        ActiveModel::Type::Boolean.new.cast(configuration.emit_blocked_words_events)
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module ChatGem
+  class ChatMessage
+    module BodyLengthValidation
+      extend ActiveSupport::Concern
+
+      private
+
+      def body_within_max_length
+        configured_limit = ChatGem.configuration.max_message_length
+        return if configured_limit.nil?
+
+        limit = configured_limit.to_i
+        return if limit <= 0
+        return if body.to_s.length <= limit
+
+        errors.add(:body, "is too long (maximum is #{limit} characters)")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module ChatGem
+  class ChatMessage
+    module Broadcasting
+      extend ActiveSupport::Concern
+
+      private
+
+      def broadcast_create
+        return unless respond_to?(:broadcast_update_to)
+
+        stream = stream_name
+
+        if message? && respond_to?(:broadcast_append_to)
+          broadcast_append_to(
+            stream,
+            target: ActionView::RecordIdentifier.dom_id(chat, :messages),
+            partial: CHAT_MESSAGE_PARTIAL,
+            locals: { chat_message: self }
+          )
+        end
+
+        broadcast_update_to(
+          stream,
+          target: ActionView::RecordIdentifier.dom_id(chat, :signals),
+          partial: SIGNALS_PARTIAL,
+          locals: { chat: chat }
+        )
+      end
+
+      def broadcast_update
+        return unless message?
+        return unless saved_change_to_body?
+        return unless respond_to?(:broadcast_replace_to)
+
+        broadcast_replace_to(
+          stream_name,
+          target: ActionView::RecordIdentifier.dom_id(self),
+          partial: MESSAGE_PARTIAL,
+          locals: { chat_message: self }
+        )
+      end
+
+      def broadcast_destroy
+        stream = stream_name
+
+        if message? && respond_to?(:broadcast_remove_to)
+          broadcast_remove_to(
+            stream,
+            target: ActionView::RecordIdentifier.dom_id(self)
+          )
+        end
+
+        self.class.broadcast_signal_refresh(chat)
+      end
+
+      def stream_name
+        [chat, STREAM_NAME]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module ChatGem
+  class ChatMessage
+    module Formatting
+      extend ActiveSupport::Concern
+
+      def participant_display_name
+        return "Unknown" if participant.nil?
+        return participant.username if participant.respond_to?(:username) && participant.username.present?
+        return participant.name if participant.respond_to?(:name) && participant.name.present?
+        return participant.email if participant.respond_to?(:email) && participant.email.present?
+
+        participant.to_s
+      end
+
+      def formatted_timestamp
+        formatted_time_for(created_at)
+      end
+
+      def formatted_updated_timestamp
+        formatted_time_for(updated_at)
+      end
+
+      def edited?
+        return false if created_at.blank? || updated_at.blank?
+
+        updated_at > created_at
+      end
+
+      def participant_membership_role
+        membership = participant_membership
+        return nil if membership.nil?
+
+        membership.effective_role_key
+      end
+
+      def formatted_participant_role
+        membership = participant_membership
+        return nil if membership.nil?
+
+        role = membership.effective_role_key
+
+        formatter = ChatGem.configuration.role_formatter
+        formatted = apply_formatter(formatter, role, self)
+        return formatted if formatted.present?
+
+        membership.effective_role_name
+      end
+
+      private
+
+      def participant_membership
+        return @participant_membership if instance_variable_defined?(:@participant_membership)
+
+        @participant_membership = chat.chat_memberships.active.find_by(participant: participant)
+      end
+
+      def formatted_time_for(timestamp)
+        formatter = ChatGem.configuration.timestamp_formatter
+        formatted = apply_formatter(formatter, timestamp, self)
+        return formatted if formatted.present?
+
+        I18n.l(timestamp.in_time_zone, format: :long)
+      end
+
+      def apply_formatter(formatter, *args)
+        return nil unless formatter.respond_to?(:call)
+
+        case formatter.arity
+        when 0
+          formatter.call
+        when 1
+          formatter.call(args.first)
+        else
+          formatter.call(*args)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+module ChatGem
+  class ChatMessage
+    module MentionValidation
+      extend ActiveSupport::Concern
+
+      private
+
+      def mentions_allowed_for_participant
+        return unless ChatGem.configuration.enable_mentions
+
+        mentions = mention_tokens
+        return if mentions.empty?
+
+        permission = mention_permission
+        if permission.nil?
+          errors.add(:body, "mentions cannot be validated at this time")
+          return
+        end
+
+        invalid_mention = first_invalid_mention(permission, mentions)
+        return if invalid_mention.nil?
+
+        errors.add(:body, mention_permission_error(invalid_mention))
+      end
+
+      def mention_tokens
+        body.to_s.scan(MENTION_PATTERN).uniq
+      end
+
+      def first_invalid_mention(permission, mentions)
+        mentions.find { |mention| !mention_allowed?(permission, mention) }
+      end
+
+      def mention_permission
+        adapter = ChatGem.configuration.permission_adapter
+        return nil unless adapter.respond_to?(:new)
+
+        adapter.new(participant, chat)
+      rescue StandardError
+        nil
+      end
+
+      def mention_allowed?(permission, mention)
+        if permission.respond_to?(:can_mention_token?)
+          return permission.can_mention_token?(mention)
+        end
+
+        case mention_kind(mention)
+        when :all
+          permission_gate_allowed?(permission, :can_mention_all?)
+        when :role
+          permission_gate_allowed?(permission, :can_mention_roles?)
+        else
+          permission_gate_allowed?(permission, :can_mention_members?)
+        end
+      rescue StandardError
+        false
+      end
+
+      def permission_gate_allowed?(permission, method_name)
+        return true unless permission.respond_to?(method_name)
+
+        permission.public_send(method_name)
+      end
+
+      def mention_kind(mention)
+        return :all if mention.casecmp("@all").zero?
+        return :role if ROLE_MENTION_PATTERN.match?(mention)
+
+        :member
+      end
+
+      def mention_permission_error(mention)
+        case mention_kind(mention)
+        when :all
+          "cannot mention @all"
+        when :role
+          "cannot mention roles"
+        else
+          "cannot mention other members"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module ChatGem
+  class ChatMessage
+    module Signals
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def start_signal!(chat:, participant:, signal_type: :typing)
+          create!(chat: chat, participant: participant, kind: :signal, signal_type: signal_type)
+        end
+
+        def replace_signal!(chat:, participant:, signal_type: :typing)
+          clear_signals!(chat: chat, participant: participant)
+          start_signal!(chat: chat, participant: participant, signal_type: signal_type)
+        end
+
+        def clear_signals!(chat:, participant:)
+          where(chat: chat, participant: participant, kind: kinds[:signal]).delete_all
+          broadcast_signal_refresh(chat)
+          true
+        end
+
+        def with_signal(chat:, participant:, signal_type: :typing)
+          replace_signal!(chat: chat, participant: participant, signal_type: signal_type)
+          yield
+        ensure
+          clear_signals!(chat: chat, participant: participant)
+        end
+
+        def broadcast_signal_refresh(chat)
+          return unless defined?(Turbo::StreamsChannel)
+
+          Turbo::StreamsChannel.broadcast_update_to(
+            [chat, STREAM_NAME],
+            target: ActionView::RecordIdentifier.dom_id(chat, :signals),
+            partial: SIGNALS_PARTIAL,
+            locals: { chat: chat }
+          )
+        end
+      end
+
+      private
+
+      def normalize_signal_fields
+        self.signal_type = nil if message?
+        self.body = "" if signal?
+      end
+
+      def replace_participant_signals_on_submit
+        return unless ChatGem.configuration.replace_signals_on_message_submit
+        return if chat_id.blank? || participant_type.blank? || participant_id.blank?
+
+        self.class.where(
+          chat_id: chat_id,
+          participant_type: participant_type,
+          participant_id: participant_id,
+          kind: self.class.kinds[:signal]
+        ).delete_all
+      end
+    end
+  end
+end

data/app/models/chat_gem/chat_message.rb

@@ -0,0 +1,40 @@
+module ChatGem
+  class ChatMessage < ApplicationRecord
+    MENTION_PATTERN = /(?<![[:alnum:]_])@[[:alpha:]][[:alnum:]_]{0,31}/.freeze
+    ROLE_MENTION_PATTERN = /\A@[A-Z][A-Z0-9_]{0,31}\z/.freeze
+    STREAM_NAME = :messages
+    MESSAGE_PARTIAL = "chat_gem/chat_messages/message"
+    CHAT_MESSAGE_PARTIAL = "chat_gem/chat_messages/chat_message"
+    SIGNALS_PARTIAL = "chat_gem/chat_messages/signals"
+
+    include ChatGem::ChatMessage::BodyLengthValidation
+    include ChatGem::ChatMessage::Formatting
+    include ChatGem::ChatMessage::MentionValidation
+    include ChatGem::ChatMessage::BlockedWordsModeration
+    include ChatGem::ChatMessage::Signals
+    include ChatGem::ChatMessage::Broadcasting
+
+    belongs_to :chat, class_name: "ChatGem::Chat", inverse_of: :chat_messages
+    belongs_to :participant, polymorphic: true
+
+    enum :kind, { message: 0, signal: 1 }, default: :message
+    enum :signal_type, { typing: 0, thinking: 1, planning: 2 }, prefix: true
+
+    scope :ordered, -> { order(created_at: :asc, id: :asc) }
+    scope :messages_only, -> { where(kind: kinds[:message]) }
+
+    validates :participant_type, :participant_id, presence: true
+    validates :body, presence: true, if: :message?
+    validates :signal_type, presence: true, if: :signal?
+    validate :body_within_max_length, if: :message?
+    validate :mentions_allowed_for_participant, if: :message?
+    validate :apply_blocked_words_moderation, if: :message?
+
+    before_validation :normalize_signal_fields
+    before_create :replace_participant_signals_on_submit, if: :message?
+
+    after_create_commit :broadcast_create
+    after_update_commit :broadcast_update
+    after_destroy_commit :broadcast_destroy
+  end
+end

data/app/views/chat_gem/chat_messages/_chat_message.html.erb

@@ -0,0 +1 @@
+<%= render "chat_gem/chat_messages/#{chat_message.kind}", chat_message: chat_message %>

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

@@ -0,0 +1,22 @@
+<% mention_permission = local_assigns[:chat_permission] %>
+<% mention_options = chat_mention_options(chat: chat, permission: mention_permission) %>
+<% mentions_enabled = chat_mentions_enabled_for?(chat: chat, permission: mention_permission) %>
+<div class="chat-composer"
+     data-chat-composer
+     data-chat-id="<%= chat.id %>"
+     data-chat-emit-typing-events="<%= ChatGem.configuration.emit_typing_events %>"
+     data-chat-emit-message-events="<%= ChatGem.configuration.emit_message_events %>"
+     data-chat-enable-mentions="<%= mentions_enabled %>"
+     data-chat-mention-options="<%= json_escape(mention_options.to_json) %>">
+  <%= form_with model: [chat, chat_message], data: { chat_message_form: true }, class: "chat-form" do |f| %>
+    <%= f.hidden_field :kind, value: :message %>
+    <%= f.text_area :body, rows: 3, required: true, placeholder: "Write a message...", data: { chat_message_input: true } %>
+    <%= f.submit "Send", class: "chat-btn chat-btn--send" %>
+  <% end %>
+
+  <%= form_with url: chat_chat_messages_path(chat), method: :post, scope: :chat_message, data: { chat_signal_form: true }, class: "chat-form chat-form--hidden" do |f| %>
+    <%= f.hidden_field :kind, value: :signal %>
+    <%= f.hidden_field :signal_type, value: :typing %>
+    <%= f.hidden_field :body, value: "" %>
+  <% end %>
+</div>

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

@@ -0,0 +1,83 @@
+<% own_message = own_chat_message?(chat_message) %>
+<% show_timestamp = ChatGem.configuration.show_timestamp %>
+<% show_role = ChatGem.configuration.show_role %>
+<% role_label = show_role ? chat_message.formatted_participant_role : nil %>
+<% edited_message = chat_message.respond_to?(:edited?) && chat_message.edited? %>
+<% bubble_style = chat_message_inline_style(chat_message: chat_message, own_message: own_message) %>
+<% mention_tokens = if respond_to?(:chat_message_mention_tokens)
+                      chat_message_mention_tokens(chat_message)
+                    else
+                      chat_message.body.to_s.scan(/(?<![[:alnum:]_])@[[:alpha:]][[:alnum:]_]{0,31}/).uniq
+                    end %>
+<% edit_message_path = if respond_to?(:chat_chat_message_path)
+                         chat_chat_message_path(chat_message.chat, chat_message)
+                       end %>
+<% can_edit_message = chat_message.persisted? && edit_message_path.present? && can_edit_chat_message?(chat_message) %>
+<% force_edit_open = local_assigns.fetch(:force_edit_open, false) && can_edit_message %>
+<article id="<%= dom_id(chat_message) %>"
+         class="<%= chat_message_css_classes(chat_message: chat_message, own_message: own_message) %>"
+         data-chat-message-id="<%= chat_message.id %>"
+         data-chat-message-participant-type="<%= chat_message.participant_type %>"
+         data-chat-message-participant-id="<%= chat_message.participant_id %>"
+         data-chat-message-mentions="<%= json_escape(mention_tokens.to_json) %>"
+         <%= %(style="#{bubble_style}") if bubble_style.present? %>>
+  <header class="chat-meta">
+    <span class="chat-meta__author"><%= chat_message.participant_display_name %></span>
+    <% if role_label.present? %>
+      <span class="chat-meta__role"><%= role_label %></span>
+    <% end %>
+    <% if show_timestamp %>
+      <time class="chat-meta__timestamp" datetime="<%= chat_message.created_at.iso8601 %>"><%= chat_message.formatted_timestamp %></time>
+    <% end %>
+    <% if edited_message %>
+      <span class="chat-meta__edited" title="Edited <%= chat_message.formatted_updated_timestamp %>">
+        edited
+      </span>
+    <% end %>
+  </header>
+
+  <div class="chat-message-view" data-chat-message-view <%= "hidden" if force_edit_open %>>
+    <%= render_chat_message_body(chat_message) %>
+  </div>
+
+  <% if can_edit_message %>
+    <footer class="chat-message-actions">
+      <button type="button"
+              class="chat-message-action"
+              data-chat-message-edit-control
+              data-chat-edit-start
+              <%= "hidden" if force_edit_open %>>
+        Edit
+      </button>
+    </footer>
+
+    <div class="chat-message-edit" data-chat-message-edit <%= "hidden" unless force_edit_open %>>
+      <% if chat_message.errors.any? %>
+        <p class="chat-inline-edit-error"><%= chat_message.errors.full_messages.to_sentence %></p>
+      <% end %>
+
+      <% edit_mention_options = chat_mention_options(chat: chat_message.chat) %>
+      <% edit_mentions_enabled = chat_mentions_enabled_for?(chat: chat_message.chat) %>
+      <%= form_with model: chat_message,
+                    url: edit_message_path,
+                    class: "chat-inline-edit-form",
+                    data: {
+                      chat_inline_edit_form: true,
+                      chat_enable_mentions: edit_mentions_enabled,
+                      chat_mention_options: json_escape(edit_mention_options.to_json)
+                    } do |f| %>
+        <div class="chat-inline-edit-field">
+          <%= f.text_area :body, rows: 3, required: true, data: { chat_inline_edit_input: true } %>
+        </div>
+        <div class="chat-inline-edit-actions">
+          <%= f.submit "Save", class: "chat-btn chat-btn--small", data: { chat_edit_save: true } %>
+          <button type="button"
+                  class="chat-btn chat-btn--ghost chat-btn--small"
+                  data-chat-edit-cancel>
+            Cancel
+          </button>
+        </div>
+      <% end %>
+    </div>
+  <% end %>
+</article>

data/app/views/chat_gem/chat_messages/_signal.html.erb

@@ -0,0 +1,3 @@
+<article id="<%= dom_id(chat_message) %>" class="chat-signal-entry">
+  <span><%= chat_message.participant_display_name %> is <%= chat_message.signal_type %>...</span>
+</article>

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

@@ -0,0 +1,24 @@
+<% show_self_signals = ChatGem.configuration.show_self_signals %>
+<% 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 %>
+
+<% chat.active_signals.each do |signal_message| %>
+  <% if !show_self_signals &&
+        current_participant_type.present? &&
+        signal_message.participant_type == current_participant_type &&
+        signal_message.participant_id == current_participant_id %>
+    <% next %>
+  <% end %>
+
+  <div class="chat-typing-indicator"
+       id="typing-<%= signal_message.participant_type.underscore %>-<%= signal_message.participant_id %>"
+       data-chat-signal-at="<%= signal_message.created_at.to_i %>"
+       data-chat-signal-participant-type="<%= signal_message.participant_type %>"
+       data-chat-signal-participant-id="<%= signal_message.participant_id %>">
+    <strong><%= signal_message.participant_display_name %></strong>
+    <span class="chat-dots">
+      <i></i><i></i><i></i>
+    </span>
+  </div>
+<% end %>

data/app/views/chat_gem/chat_messages/index.html.erb

@@ -0,0 +1 @@
+<%= render @chat_messages %>

data/app/views/chat_gem/chats/index.html.erb

@@ -0,0 +1,51 @@
+<section class="chat-shell"
+         data-chat-index
+         data-chat-emit-invitation-events="<%= chat_emit_invitation_events? %>"
+         data-chat-emit-chat-lifecycle-events="<%= chat_emit_chat_lifecycle_events? %>"
+         data-chat-invitation-accepted="<%= json_escape(@invitation_accepted_event.to_json) if @invitation_accepted_event.present? %>"
+         data-chat-lifecycle-event="<%= json_escape(@chat_lifecycle_event.to_json) if @chat_lifecycle_event.present? %>">
+  <header class="chat-header">
+    <h1>Chats</h1>
+    <%= link_to "New Chat", new_chat_path, class: "chat-btn" %>
+  </header>
+
+  <% if @pending_invitations.present? %>
+    <section class="chat-invitations">
+      <h2>Pending Invitations</h2>
+      <ul class="chat-list">
+        <% @pending_invitations.each do |membership| %>
+          <% invitation_chat = membership.chat %>
+          <li class="chat-list-item chat-list-item--invitation">
+            <span class="chat-list-title"><%= invitation_chat.title %></span>
+            <div class="chat-list-actions">
+              <%= button_to "Accept",
+                            accept_chat_path(invitation_chat),
+                            method: :patch,
+                            form_class: "chat-inline-form",
+                            class: "chat-btn chat-btn--success chat-btn--small" %>
+              <%= button_to "Decline",
+                            decline_chat_path(invitation_chat),
+                            method: :patch,
+                            form_class: "chat-inline-form",
+                            class: "chat-btn chat-btn--danger chat-btn--small" %>
+            </div>
+          </li>
+        <% end %>
+      </ul>
+    </section>
+  <% end %>
+
+  <section class="chat-joined">
+    <h2>Your Chats</h2>
+    <ul class="chat-list">
+      <% @chats.each do |chat| %>
+        <li>
+          <%= link_to chat.title, chat_path(chat), class: "chat-list-link" %>
+        </li>
+      <% end %>
+    </ul>
+    <% if @chats.empty? %>
+      <p class="chat-hint">No accepted chats yet.</p>
+    <% end %>
+  </section>
+</section>

data/app/views/chat_gem/chats/new.html.erb

@@ -0,0 +1,13 @@
+<section class="chat-shell">
+  <header class="chat-header">
+    <h1>New Chat</h1>
+  </header>
+
+  <%= form_with model: @chat, url: chats_path do |f| %>
+    <div class="chat-field">
+      <%= f.label :title %>
+      <%= f.text_field :title, required: true, autofocus: true %>
+    </div>
+    <%= f.submit "Create", class: "chat-btn" %>
+  <% end %>
+</section>