turbo_chat 0.1.0

data/app/controllers/chat_gem/application_controller.rb

@@ -0,0 +1,41 @@
+module ChatGem
+  class ApplicationController < ::ApplicationController
+    layout "chat_gem/application"
+
+    helper_method :current_chat_participant
+
+    private
+
+    def current_chat_participant
+      method_name = :chat_current_participant
+      raise NotImplementedError, "Define ##{method_name} in your host application controller" unless respond_to?(method_name, true)
+
+      participant = send(method_name)
+      return participant if participant.nil? || participant.respond_to?(:active_chat_memberships)
+
+      raise ArgumentError, "##{method_name} must return a model that uses `acts_as_chat_participant`"
+    end
+
+    def permission_for(chat = nil)
+      ChatGem.configuration.permission_adapter.new(current_chat_participant, chat)
+    end
+
+    def authorize_create_chat!
+      return if permission_for.can_create_chat?
+
+      head :forbidden
+    end
+
+    def authorize_view_chat!(chat)
+      return if permission_for(chat).can_view_chat?
+
+      head :forbidden
+    end
+
+    def authorize_post_message!(chat)
+      return if permission_for(chat).can_post_message?
+
+      head :forbidden
+    end
+  end
+end

data/app/controllers/chat_gem/chat_memberships_controller.rb

@@ -0,0 +1,81 @@
+module ChatGem
+  class ChatMembershipsController < ApplicationController
+    include ChatGem::ChatsController::EventPayloadSupport
+
+    before_action :set_chat
+    before_action -> { authorize_view_chat!(@chat) }
+    before_action :authorize_invite_member!
+
+    def create
+      participant = invite_participant
+      membership = @chat.chat_memberships.find_or_initialize_by(participant: participant)
+      pending_invitation_attributes = invitation_pending_attributes
+
+      if membership.persisted?
+        membership.assign_attributes(
+          removed_at: nil,
+          muted: false,
+          timed_out_until: nil
+        )
+        membership.assign_attributes(pending_invitation_attributes)
+      else
+        membership.assign_attributes(role: :member)
+        membership.assign_attributes(pending_invitation_attributes)
+      end
+
+      membership.save!
+      set_chat_lifecycle_event(action: :invited, chat: @chat, membership: membership)
+      redirect_to chat_path(@chat), notice: "Participant invited"
+    rescue ActiveRecord::RecordNotFound
+      redirect_to chat_path(@chat), alert: "Participant not found"
+    rescue NameError, ArgumentError
+      redirect_to chat_path(@chat), alert: "Invalid participant type"
+    rescue ActiveRecord::RecordInvalid => error
+      redirect_to chat_path(@chat), alert: error.record.errors.full_messages.to_sentence
+    end
+
+    private
+
+    def set_chat
+      @chat = ChatGem::Chat.find(params[:chat_id])
+    end
+
+    def authorize_invite_member!
+      permission = permission_for(@chat)
+      return if permission.respond_to?(:can_invite_member?) && permission.can_invite_member?
+
+      head :forbidden
+    end
+
+    def invite_params
+      params.require(:chat_membership).permit(:participant_type, :participant_id)
+    end
+
+    def invite_participant
+      participant_type = invite_params.fetch(:participant_type).to_s
+      participant_id = invite_params.fetch(:participant_id).to_s
+      raise ArgumentError if participant_type.blank? || participant_id.blank?
+
+      participant_class = participant_type.safe_constantize
+      raise NameError if participant_class.nil?
+      raise ArgumentError unless participant_class < ActiveRecord::Base
+      raise ArgumentError unless participant_class.method_defined?(:active_chat_memberships)
+      raise ArgumentError unless invite_type_allowed?(participant_class)
+
+      participant_class.find(participant_id)
+    end
+
+    def invite_type_allowed?(participant_class)
+      inviter = current_chat_participant
+      return false if inviter.nil?
+
+      participant_class.base_class.name == inviter.class.base_class.name
+    end
+
+    def invitation_pending_attributes
+      return {} unless ChatGem::ChatMembership.invitation_tracking_supported?
+
+      { invitation_accepted: false }
+    end
+  end
+end

data/app/controllers/chat_gem/chat_messages_controller.rb

@@ -0,0 +1,144 @@
+module ChatGem
+  class ChatMessagesController < ApplicationController
+    before_action :set_chat
+    before_action -> { authorize_view_chat!(@chat) }, only: :index
+    before_action -> { authorize_post_message!(@chat) }, only: :create
+    before_action :set_chat_message, only: :update
+    before_action :authorize_edit_chat_message!, only: :update
+
+    def index
+      @chat_messages = @chat.visible_messages
+    end
+
+    def create
+      return respond_to_clear_signal_request if clear_signal_request?
+
+      build_chat_message
+
+      if @chat_message.save
+        respond_to_chat_message_create_success
+      else
+        respond_to_chat_message_create_failure
+      end
+    end
+
+    def update
+      if @chat_message.update(edit_chat_message_params)
+        return render_chat_message_update if turbo_stream_request?
+
+        redirect_to chat_path(@chat), notice: "Message updated"
+      else
+        return render_chat_message_update(force_edit_open: true, status: :unprocessable_entity) if turbo_stream_request?
+
+        redirect_to chat_path(@chat), alert: @chat_message.errors.full_messages.to_sentence
+      end
+    end
+
+    private
+
+    def set_chat
+      @chat = ChatGem::Chat.find(params[:chat_id])
+    end
+
+    def chat_message_params
+      params.require(:chat_message).permit(:body, :kind, :signal_type)
+    end
+
+    def edit_chat_message_params
+      params.require(:chat_message).permit(:body)
+    end
+
+    def signal_request?
+      params.dig(:chat_message, :kind).to_s == "signal"
+    end
+
+    def clear_signal_request?
+      return false unless signal_request?
+
+      ActiveModel::Type::Boolean.new.cast(params.dig(:chat_message, :clear))
+    end
+
+    def build_chat_message
+      @chat_message = @chat.chat_messages.build(chat_message_params)
+      @chat_message.participant = current_chat_participant
+    end
+
+    def respond_to_clear_signal_request
+      ChatGem::ChatMessage.clear_signals!(chat: @chat, participant: current_chat_participant)
+      respond_to do |format|
+        format.turbo_stream { render_signals_update }
+        format.html { redirect_to chat_path(@chat) }
+      end
+    end
+
+    def respond_to_chat_message_create_success
+      respond_to do |format|
+        format.turbo_stream do
+          signal_request? ? render_signals_update : head(:ok)
+        end
+        format.html { redirect_to chat_path(@chat) }
+      end
+    end
+
+    def respond_to_chat_message_create_failure
+      @chat_messages = @chat.visible_messages
+      @chat_permission = permission_for(@chat)
+      @can_post_message = @chat_permission.can_post_message?
+      respond_to do |format|
+        format.turbo_stream { render "chat_gem/chats/show", status: :unprocessable_entity }
+        format.html { render "chat_gem/chats/show", status: :unprocessable_entity }
+      end
+    end
+
+    def render_signals_update
+      render turbo_stream: turbo_stream.update(
+        view_context.dom_id(@chat, :signals),
+        partial: "chat_gem/chat_messages/signals",
+        locals: { chat: @chat }
+      )
+    end
+
+    def set_chat_message
+      @chat_message = @chat.chat_messages.messages_only.find(params[:id])
+    end
+
+    def authorize_edit_chat_message!
+      chat_permission = permission_for(@chat)
+      can_edit = if chat_permission.respond_to?(:can_edit_message?)
+                   chat_permission.can_edit_message?(@chat_message)
+                 else
+                   can_post = if chat_permission.respond_to?(:can_post_message?)
+                                chat_permission.can_post_message?
+                              elsif chat_permission.respond_to?(:can_view_chat?)
+                                chat_permission.can_view_chat?
+                              else
+                                false
+                              end
+
+                   can_post &&
+                     @chat_message.participant_type.to_s == current_chat_participant.class.base_class.name &&
+                     @chat_message.participant_id.to_s == current_chat_participant.id.to_s
+                 end
+      return if can_edit
+
+      respond_to do |format|
+        format.html { redirect_to chat_path(@chat), alert: "Not allowed to edit this message" }
+        format.any { head :forbidden }
+      end
+    end
+
+    def render_chat_message_update(force_edit_open: false, status: :ok)
+      locals = { chat_message: @chat_message }
+      locals[:force_edit_open] = true if force_edit_open
+      render turbo_stream: turbo_stream.replace(
+        view_context.dom_id(@chat_message),
+        partial: "chat_gem/chat_messages/message",
+        locals: locals
+      ), status: status
+    end
+
+    def turbo_stream_request?
+      request.headers["Accept"].to_s.include?("turbo-stream")
+    end
+  end
+end

data/app/controllers/chat_gem/chats_controller/event_payload_support.rb

@@ -0,0 +1,58 @@
+module ChatGem
+  class ChatsController < ApplicationController
+    module EventPayloadSupport
+      private
+
+      def invitation_accepted_payload
+        payload = flash[:chat_gem_invitation_accepted]
+        return nil unless payload.respond_to?(:to_h)
+
+        symbolized_payload = payload.to_h.symbolize_keys
+        chat_id = symbolized_payload[:chatId].presence || symbolized_payload[:chat_id].presence
+        return nil if chat_id.blank?
+
+        {
+          chatId: chat_id.to_s,
+          chatTitle: symbolized_payload[:chatTitle].presence || symbolized_payload[:chat_title].presence,
+          chatMembershipId: symbolized_payload[:chatMembershipId].presence || symbolized_payload[:chat_membership_id].presence
+        }.compact
+      rescue StandardError
+        nil
+      end
+
+      def chat_lifecycle_event_payload
+        payload = flash[:chat_gem_chat_lifecycle_event]
+        return nil unless payload.respond_to?(:to_h)
+
+        symbolized_payload = payload.to_h.symbolize_keys
+        event_name = symbolized_payload[:eventName].presence || symbolized_payload[:event_name].presence
+        return nil if event_name.blank?
+
+        chat_id = symbolized_payload[:chatId].presence || symbolized_payload[:chat_id].presence
+
+        {
+          eventName: event_name.to_s,
+          action: symbolized_payload[:action].presence,
+          chatId: chat_id.to_s.presence,
+          chatTitle: symbolized_payload[:chatTitle].presence || symbolized_payload[:chat_title].presence,
+          chatMembershipId: symbolized_payload[:chatMembershipId].presence || symbolized_payload[:chat_membership_id].presence
+        }.compact
+      rescue StandardError
+        nil
+      end
+
+      def set_chat_lifecycle_event(action:, chat:, membership: nil)
+        return if action.blank? || chat.nil?
+
+        action_key = action.to_s
+        flash[:chat_gem_chat_lifecycle_event] = {
+          eventName: "chat-gem:chat-#{action_key}",
+          action: action_key,
+          chatId: chat.id.to_s,
+          chatTitle: chat.title,
+          chatMembershipId: membership&.id&.to_s
+        }.compact
+      end
+    end
+  end
+end

data/app/controllers/chat_gem/chats_controller/invitation_support.rb

@@ -0,0 +1,31 @@
+module ChatGem
+  class ChatsController < ApplicationController
+    module InvitationSupport
+      private
+
+      def build_invitable_participants
+        participant_type = current_chat_participant.class.base_class.name
+        participant_class = participant_type.safe_constantize
+        return [] if participant_class.nil?
+        return [] unless participant_class < ActiveRecord::Base
+        return [] unless participant_class.method_defined?(:active_chat_memberships)
+
+        current_member_ids = @chat.chat_memberships.where(removed_at: nil, participant_type: participant_type).pluck(:participant_id)
+        participant_class.where.not(id: current_member_ids).order(id: :asc).limit(100).to_a
+      rescue StandardError
+        []
+      end
+
+      def pending_invitations_for(participant)
+        return ChatGem::ChatMembership.none if participant.nil?
+        return ChatGem::ChatMembership.none unless ChatGem::ChatMembership.invitation_tracking_supported?
+
+        ChatGem::ChatMembership
+          .pending
+          .where(participant: participant)
+          .includes(:chat)
+          .order(created_at: :desc, id: :desc)
+      end
+    end
+  end
+end

data/app/controllers/chat_gem/chats_controller.rb

@@ -0,0 +1,125 @@
+module ChatGem
+  class ChatsController < ApplicationController
+    include ChatGem::ChatsController::InvitationSupport
+    include ChatGem::ChatsController::EventPayloadSupport
+
+    before_action :authorize_create_chat!, only: %i[new create]
+    before_action :set_chat, only: %i[show accept decline leave close reopen]
+
+    def index
+      participant = current_chat_participant
+      @chats = ChatGem::Chat.for_participant(participant).order(created_at: :desc, id: :desc)
+      @pending_invitations = pending_invitations_for(participant)
+      @invitation_accepted_event = invitation_accepted_payload
+      @chat_lifecycle_event = chat_lifecycle_event_payload
+    end
+
+    def accept
+      participant = current_chat_participant
+      return head :forbidden if participant.nil?
+      return redirect_to(chats_path, alert: "Run latest chat_gem migrations to accept invitations", status: :see_other) unless ChatGem::ChatMembership.invitation_tracking_supported?
+
+      membership = @chat.chat_memberships.pending.find_by(participant: participant)
+      return redirect_to(chats_path, alert: "Invitation not found", status: :see_other) if membership.nil?
+
+      membership.accept_invitation!
+      flash[:chat_gem_invitation_accepted] = {
+        chatId: @chat.id,
+        chatTitle: @chat.title,
+        chatMembershipId: membership.id
+      }
+      set_chat_lifecycle_event(action: :joined, chat: @chat, membership: membership)
+      redirect_to chats_path, notice: "Invitation accepted", status: :see_other
+    end
+
+    def decline
+      participant = current_chat_participant
+      return head :forbidden if participant.nil?
+      return redirect_to(chats_path, alert: "Run latest chat_gem migrations to decline invitations", status: :see_other) unless ChatGem::ChatMembership.invitation_tracking_supported?
+
+      membership = @chat.chat_memberships.pending.find_by(participant: participant)
+      return redirect_to(chats_path, alert: "Invitation not found", status: :see_other) if membership.nil?
+
+      membership.update!(removed_at: Time.current, muted: false, timed_out_until: nil, invitation_accepted: false)
+      set_chat_lifecycle_event(action: :declined, chat: @chat, membership: membership)
+      redirect_to chats_path, notice: "Invitation declined", status: :see_other
+    end
+
+    def new
+      @chat = ChatGem::Chat.new
+    end
+
+    def create
+      @chat = ChatGem::Chat.new(chat_params)
+
+      if @chat.save
+        membership = @chat.chat_memberships.create!(participant: current_chat_participant, role: :admin)
+        set_chat_lifecycle_event(action: :joined, chat: @chat, membership: membership)
+        redirect_to chat_path(@chat), notice: "Chat created"
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def show
+      authorize_view_chat!(@chat)
+      return if performed?
+
+      @chat_lifecycle_event = chat_lifecycle_event_payload
+      @chat_permission = permission_for(@chat)
+      @chat_messages = @chat.visible_messages
+      @can_post_message = @chat_permission.can_post_message?
+      @can_invite_member = @chat_permission.respond_to?(:can_invite_member?) && @chat_permission.can_invite_member?
+      @can_close_chat = @chat_permission.can_close_chat?
+      @can_reopen_chat = @chat_permission.can_reopen_chat?
+      @can_edit_own_messages = if @chat_permission.respond_to?(:can_edit_message?)
+                                 @chat_permission.can_edit_message?
+                               else
+                                 @chat_permission.can_post_message?
+                               end
+      @chat_message = @chat.chat_messages.build if @can_post_message
+      @invitable_participants = build_invitable_participants if @can_invite_member
+      @invite_participant_type = current_chat_participant.class.base_class.name if @can_invite_member
+    end
+
+    def leave
+      authorize_view_chat!(@chat)
+      return if performed?
+
+      membership = @chat.chat_memberships.active.find_by(participant: current_chat_participant)
+      return redirect_to(chats_path, alert: "You are no longer a participant in this chat", status: :see_other) if membership.nil?
+
+      membership.update!(removed_at: Time.current, muted: false, timed_out_until: nil)
+      set_chat_lifecycle_event(action: :left, chat: @chat, membership: membership)
+      redirect_to chats_path, notice: "You left the chat", status: :see_other
+    end
+
+    def close
+      chat_permission = permission_for(@chat)
+      return head :forbidden unless chat_permission.can_close_chat?
+
+      @chat.close!
+      set_chat_lifecycle_event(action: :closed, chat: @chat)
+      redirect_to chat_path(@chat), notice: "Chat closed", status: :see_other
+    end
+
+    def reopen
+      chat_permission = permission_for(@chat)
+      return head :forbidden unless chat_permission.can_reopen_chat?
+
+      @chat.reopen!
+      set_chat_lifecycle_event(action: :reopened, chat: @chat)
+      redirect_to chat_path(@chat), notice: "Chat reopened", status: :see_other
+    end
+
+    private
+
+    def set_chat
+      @chat = ChatGem::Chat.find(params[:id])
+    end
+
+    def chat_params
+      params.require(:chat).permit(:title)
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module ChatGem
+  module ApplicationHelper
+    module ConfigSupport
+      def chat_mention_filter_exclude_self?
+        chat_config_boolean(:mention_filter_exclude_self, default: true)
+      end
+
+      def chat_mention_filter_hide_roles?
+        chat_config_boolean(:mention_filter_hide_roles, default: true)
+      end
+
+      def chat_emit_mention_events?
+        chat_config_boolean(:emit_mention_events, default: false)
+      end
+
+      def chat_emit_invitation_events?
+        chat_config_boolean(:emit_invitation_events, default: false)
+      end
+
+      def chat_emit_chat_lifecycle_events?
+        chat_config_boolean(:emit_chat_lifecycle_events, default: false)
+      end
+
+      private
+
+      def chat_config_value(method_name, default: nil)
+        configuration = ChatGem.configuration
+        return default unless configuration.respond_to?(method_name)
+
+        configuration.public_send(method_name)
+      rescue StandardError
+        default
+      end
+
+      def chat_config_boolean(method_name, default:)
+        value = chat_config_value(method_name, default: default)
+        ActiveModel::Type::Boolean.new.cast(value)
+      end
+    end
+  end
+end

data/app/helpers/chat_gem/application_helper/mention_support/entry_builder.rb

@@ -0,0 +1,55 @@
+module ChatGem
+  module ApplicationHelper
+    module MentionSupport
+      module EntryBuilder
+        private
+
+        def chat_member_mention_entries(chat)
+          taken_tokens = {}
+
+          active_chat_memberships(chat).each_with_object([]) do |membership, entries|
+            participant = membership.participant
+            next if participant.nil?
+
+            identifier = normalized_mention_identifier(participant_mention_base_identifier(participant))
+            identifier = fallback_mention_identifier(participant) if identifier.blank?
+            token = unique_mention_token(identifier, taken_tokens)
+
+            entries << {
+              token: token,
+              label: chat_participant_name(participant),
+              participant: participant,
+              participant_type: participant.class.base_class.name,
+              participant_id: participant.id
+            }
+          end
+        end
+
+        def chat_role_mention_entries(chat)
+          role_tokens = {}
+
+          active_chat_memberships(chat).each_with_object([]) do |membership, entries|
+            role_key = membership.effective_role_key.to_s.strip
+            next if role_key.blank?
+
+            role_token = "@#{role_key.upcase}"
+            next if role_tokens[role_token]
+
+            role_tokens[role_token] = true
+            entries << {
+              token: role_token,
+              label: "#{membership.effective_role_name} role",
+              kind: "role"
+            }
+          end
+        end
+
+        def active_chat_memberships(chat)
+          return [] unless chat.respond_to?(:chat_memberships)
+
+          chat.chat_memberships.active.includes(:participant).order(:id)
+        end
+      end
+    end
+  end
+end

data/app/helpers/chat_gem/application_helper/mention_support/permission_support.rb

@@ -0,0 +1,28 @@
+module ChatGem
+  module ApplicationHelper
+    module MentionSupport
+      module PermissionSupport
+        private
+
+        def mention_permission_for(chat)
+          return nil unless respond_to?(:current_chat_participant, true)
+
+          participant = current_chat_participant
+          return nil if participant.nil?
+
+          ChatGem.configuration.permission_adapter.new(participant, chat)
+        rescue StandardError
+          nil
+        end
+
+        def mention_permission_allows?(permission, method_name)
+          return true unless permission.respond_to?(method_name)
+
+          permission.public_send(method_name)
+        rescue StandardError
+          false
+        end
+      end
+    end
+  end
+end

data/app/helpers/chat_gem/application_helper/mention_support/token_builder.rb

@@ -0,0 +1,49 @@
+module ChatGem
+  module ApplicationHelper
+    module MentionSupport
+      module TokenBuilder
+        private
+
+        def participant_mention_base_identifier(participant)
+          return participant.username if participant.respond_to?(:username) && participant.username.present?
+          if participant.respond_to?(:email) && participant.email.present?
+            return participant.email.to_s.split("@").first
+          end
+          return participant.name if participant.respond_to?(:name) && participant.name.present?
+
+          participant.to_s
+        end
+
+        def fallback_mention_identifier(participant)
+          participant_id = participant.respond_to?(:id) ? participant.id : nil
+          return "member_#{participant_id}" if participant_id.present?
+
+          "member"
+        end
+
+        def normalized_mention_identifier(value)
+          slug = I18n.transliterate(value.to_s)
+          slug = slug.downcase.gsub(/[^a-z0-9_]+/, "_").gsub(/\A_+|_+\z/, "").squeeze("_")
+          slug = "member_#{slug}" if slug.match?(/\A\d/)
+          slug.presence
+        end
+
+        def unique_mention_token(identifier, taken_tokens)
+          base = normalized_mention_identifier(identifier) || "member"
+          token = "@#{base}"
+          return taken_tokens[token] = token unless taken_tokens.key?(token)
+
+          suffix = 2
+          loop do
+            candidate = "@#{base}_#{suffix}"
+            unless taken_tokens.key?(candidate)
+              taken_tokens[candidate] = candidate
+              return candidate
+            end
+            suffix += 1
+          end
+        end
+      end
+    end
+  end
+end