turbo_chat 0.1.0

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

@@ -0,0 +1,80 @@
+module ChatGem
+  module ApplicationHelper
+    module MentionSupport
+      include ChatGem::ApplicationHelper::MentionSupport::TokenBuilder
+      include ChatGem::ApplicationHelper::MentionSupport::EntryBuilder
+      include ChatGem::ApplicationHelper::MentionSupport::PermissionSupport
+
+      def chat_mention_options(chat:, permission: nil)
+        mention_permission = permission || mention_permission_for(chat)
+        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?
+        viewer_participant = mention_viewer_participant(permission: mention_permission)
+
+        options = []
+        options << { token: "@all", label: "All members", kind: "group" } if allow_all_mentions
+        return options unless chat.respond_to?(:chat_memberships)
+
+        if allow_member_mentions
+          chat_member_mention_entries(chat).each do |entry|
+            next if exclude_self_mentions && same_chat_participant?(entry[:participant], viewer_participant)
+
+            options << {
+              token: entry[:token],
+              label: entry[:label],
+              kind: "member",
+              participant_type: entry[:participant_type],
+              participant_id: entry[:participant_id]
+            }
+          end
+        end
+
+        if allow_role_mentions
+          options.concat(chat_role_mention_entries(chat))
+        end
+
+        options
+      end
+
+      def chat_self_mention_tokens(chat:, participant: nil)
+        viewer = participant || current_chat_participant_for_view
+        return [] if viewer.nil?
+        return [] unless chat.respond_to?(:chat_memberships)
+
+        chat_member_mention_entries(chat).each_with_object([]) do |entry, tokens|
+          next unless same_chat_participant?(entry[:participant], viewer)
+
+          tokens << entry[:token]
+        end
+      end
+
+      def chat_self_role_mention_token(chat:, participant: nil)
+        viewer = participant || current_chat_participant_for_view
+        return nil if viewer.nil?
+        return nil unless chat.respond_to?(:chat_memberships)
+
+        membership = chat.chat_memberships.active.find_by(participant: viewer)
+        return nil if membership.nil?
+
+        role_key = membership.effective_role_key.to_s.strip
+        return nil if role_key.blank?
+
+        "@#{role_key.upcase}"
+      end
+
+      def chat_mentions_enabled_for?(chat:, permission: nil)
+        return false unless ChatGem.configuration.enable_mentions
+
+        mention_permission = permission || mention_permission_for(chat)
+        return true if mention_permission.nil?
+
+        mention_permission_allows?(mention_permission, :can_mention_members?) ||
+          mention_permission_allows?(mention_permission, :can_mention_all?) ||
+          mention_permission_allows?(mention_permission, :can_mention_roles?)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+module ChatGem
+  module ApplicationHelper
+    module MessageRendering
+      def chat_message_css_classes(chat_message:, own_message:)
+        classes = ["chat-bubble"]
+        classes << "chat-bubble--own" if own_message
+        classes.concat(resolve_custom_message_css_classes(chat_message: chat_message, own_message: own_message))
+        classes.uniq.join(" ")
+      end
+
+      def chat_message_inline_style(chat_message:, own_message:)
+        hex_color = resolve_message_hex_color(chat_message: chat_message, own_message: own_message)
+        return nil if hex_color.blank?
+
+        "--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))
+        hex_color ||= normalize_hex_color(chat_config_value(:mention_highlight_hex_color))
+        return nil if hex_color.blank?
+
+        mention_mark_background = hex_color_with_alpha(hex_color, alpha: 0.22)
+        "--chat-mention-highlight-color: #{hex_color}; --chat-mention-mark-background: #{mention_mark_background};"
+      end
+
+      def render_chat_message_body(chat_message)
+        body = chat_message.body.to_s
+        return content_tag(:p, decorate_plain_message_text(body).html_safe, class: "chat-body") unless ChatGem.configuration.render_message_html
+
+        sanitized_html = sanitize(
+          body,
+          tags: Array(ChatGem.configuration.message_html_tags),
+          attributes: Array(ChatGem.configuration.message_html_attributes)
+        )
+        content_tag(:div, sanitized_html, class: "chat-body")
+      end
+
+      def chat_message_mention_tokens(chat_message)
+        return [] unless ChatGem.configuration.enable_mentions
+        return [] if chat_message.nil?
+
+        chat_message.body.to_s.scan(MENTION_PATTERN).uniq
+      end
+
+      private
+
+      def resolve_custom_message_css_classes(chat_message:, own_message:)
+        resolver = ChatGem.configuration.message_css_class_resolver
+        return [] unless resolver.respond_to?(:call)
+
+        classes = case resolver.arity
+        when 0
+          resolver.call
+        when 1
+          resolver.call(chat_message)
+        when 2
+          resolver.call(chat_message, own_message)
+        else
+          resolver.call(chat_message, own_message, self)
+        end
+
+        Array(classes).flat_map { |value| value.to_s.split(/\s+/) }.reject(&:blank?)
+      rescue ArgumentError
+        []
+      end
+
+      def resolve_message_hex_color(chat_message:, own_message:)
+        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 ? ChatGem.configuration.own_message_hex_color : ChatGem.configuration.other_message_hex_color
+        normalize_hex_color(base_color)
+      end
+
+      def resolve_role_message_hex_color(chat_message:, own_message:)
+        role_colors = ChatGem.configuration.role_message_hex_colors
+        return nil unless role_colors.is_a?(Hash)
+
+        role_key = chat_message_role_key(chat_message)
+        return nil if role_key.blank?
+
+        role_config = role_colors[role_key] || role_colors[role_key.to_sym]
+        return normalize_hex_color(role_config) unless role_config.is_a?(Hash)
+
+        variant = if own_message
+                    role_config[:own] || role_config["own"]
+                  else
+                    role_config[:other] || role_config["other"]
+                  end
+
+        variant ||= role_config[:default] || role_config["default"]
+        normalize_hex_color(variant)
+      end
+
+      def chat_message_role_key(chat_message)
+        return nil unless chat_message.respond_to?(:participant_membership_role)
+
+        chat_message.participant_membership_role.to_s.strip.presence
+      end
+
+      def normalize_hex_color(value)
+        candidate = value.to_s.strip
+        return nil if candidate.blank?
+
+        candidate = "##{candidate}" unless candidate.start_with?("#")
+        return nil unless HEX_COLOR_PATTERN.match?(candidate)
+
+        candidate.downcase
+      end
+
+      def hex_color_with_alpha(hex_color, alpha:)
+        normalized_hex = normalize_hex_color(hex_color)
+        return nil if normalized_hex.blank?
+
+        red, green, blue = case normalized_hex.length
+                           when 4
+                             [
+                               normalized_hex[1] * 2,
+                               normalized_hex[2] * 2,
+                               normalized_hex[3] * 2
+                             ]
+                           when 7, 9
+                             [
+                               normalized_hex[1, 2],
+                               normalized_hex[3, 2],
+                               normalized_hex[5, 2]
+                             ]
+                           else
+                             return nil
+                           end
+
+        alpha_value = alpha.to_f
+        alpha_value = 0.0 if alpha_value.negative?
+        alpha_value = 1.0 if alpha_value > 1.0
+
+        alpha_hex = (alpha_value * 255).round.to_s(16).rjust(2, "0")
+        "##{red}#{green}#{blue}#{alpha_hex}".downcase
+      end
+
+      def decorate_plain_message_text(body)
+        formatted = ERB::Util.html_escape(body.to_s)
+        formatted = apply_emoji_aliases(formatted) if ChatGem.configuration.enable_emoji_aliases
+        formatted = apply_mention_highlights(formatted) if ChatGem.configuration.enable_mentions
+        formatted.gsub(/\r\n?|\n/, "<br>")
+      end
+
+      def apply_emoji_aliases(text)
+        emoji_aliases = ChatGem.configuration.effective_emoji_aliases
+        return text if emoji_aliases.empty?
+
+        text.gsub(EMOJI_ALIAS_PATTERN) do |match|
+          alias_key = Regexp.last_match(1).to_s.downcase
+          emoji_aliases.fetch(alias_key, match)
+        end
+      end
+
+      def apply_mention_highlights(text)
+        text.gsub(MENTION_PATTERN) do |mention|
+          %(<span class="chat-mention">#{mention}</span>)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module ChatGem
+  module ApplicationHelper
+    module ParticipantSupport
+      def chat_participant_name(participant)
+        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 own_chat_message?(chat_message, participant: nil)
+        return false if chat_message.nil?
+
+        participant ||= current_chat_participant_for_view
+        return false if participant.nil?
+
+        participant_type = participant.class.base_class.name
+        participant_id = participant.id
+        return false if participant_type.blank? || participant_id.blank?
+
+        chat_message.participant_type.to_s == participant_type &&
+          chat_message.participant_id.to_s == participant_id.to_s
+      end
+
+      def can_edit_chat_message?(chat_message, participant: nil)
+        return false if chat_message.nil?
+
+        participant ||= current_chat_participant_for_view
+        if participant.nil?
+          return true unless respond_to?(:current_chat_participant, true)
+
+          return false
+        end
+
+        adapter = ChatGem.configuration.permission_adapter
+        return false unless adapter.respond_to?(:new)
+
+        permission = adapter.new(participant, chat_message.chat)
+        if permission.respond_to?(:can_edit_message?)
+          return permission.can_edit_message?(chat_message)
+        end
+
+        return false if permission.respond_to?(:can_post_message?) && !permission.can_post_message?
+
+        own_chat_message?(chat_message, participant: participant)
+      rescue StandardError
+        false
+      end
+
+      private
+
+      def current_chat_participant_for_view
+        return nil unless respond_to?(:current_chat_participant, true)
+
+        current_chat_participant
+      rescue StandardError
+        nil
+      end
+
+      def mention_viewer_participant(permission:)
+        return permission.participant if permission.respond_to?(:participant) && permission.participant.present?
+
+        current_chat_participant_for_view
+      end
+
+      def same_chat_participant?(first, second)
+        return false if first.nil? || second.nil?
+        return false unless first.respond_to?(:id) && second.respond_to?(:id)
+
+        first_type = first.class.base_class.name
+        second_type = second.class.base_class.name
+        return false if first_type.blank? || second_type.blank?
+        return false if first.id.blank? || second.id.blank?
+
+        first_type == second_type && first.id.to_s == second.id.to_s
+      end
+    end
+  end
+end

data/app/helpers/chat_gem/application_helper.rb

@@ -0,0 +1,12 @@
+module ChatGem
+  module ApplicationHelper
+    HEX_COLOR_PATTERN = /\A#(?:\h{3}|\h{6}|\h{8})\z/.freeze
+    EMOJI_ALIAS_PATTERN = /:([a-z0-9_+\-]{2,32}):/i.freeze
+    MENTION_PATTERN = /(?<![[:alnum:]_])@[[:alpha:]][[:alnum:]_]{0,31}/.freeze
+
+    include ChatGem::ApplicationHelper::ConfigSupport
+    include ChatGem::ApplicationHelper::ParticipantSupport
+    include ChatGem::ApplicationHelper::MessageRendering
+    include ChatGem::ApplicationHelper::MentionSupport
+  end
+end

data/app/models/chat_gem/application_record.rb

@@ -0,0 +1,5 @@
+module ChatGem
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/chat_gem/chat.rb

@@ -0,0 +1,127 @@
+module ChatGem
+  class Chat < ApplicationRecord
+    has_many :chat_memberships,
+             class_name: "ChatGem::ChatMembership",
+             dependent: :destroy,
+             inverse_of: :chat
+
+    has_many :chat_messages,
+             class_name: "ChatGem::ChatMessage",
+             dependent: :destroy,
+             inverse_of: :chat
+
+    validates :title, presence: true
+
+    scope :for_participant, lambda { |participant|
+      return none if participant.nil?
+
+      joins(:chat_memberships)
+        .merge(ChatGem::ChatMembership.active.where(participant: participant))
+        .distinct
+    }
+    scope :opened, -> { where(closed_at: nil) }
+    scope :closed, -> { where.not(closed_at: nil) }
+
+    scope :active, lambda { |window: nil|
+      cutoff = Time.current - activity_window_seconds(window)
+      joins(:chat_messages)
+        .merge(ChatGem::ChatMessage.message.where("#{ChatGem::ChatMessage.table_name}.created_at >= ?", cutoff))
+        .distinct
+    }
+
+    scope :inactive, lambda { |window: nil|
+      where.not(id: active(window: window).select(:id))
+    }
+
+    def active_signals(window: 12.seconds)
+      cutoff = Time.current - window
+      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
+
+        key = "#{message.participant_type}-#{message.participant_id}"
+        next if seen[key]
+
+        output << message
+        seen[key] = true
+      end.reverse
+    end
+
+    def visible_messages(limit: ChatGem.configuration.message_history_limit)
+      relation = chat_messages.messages_only
+      normalized_limit = normalize_message_limit(limit)
+      limited_relation = if normalized_limit.nil?
+                           relation
+                         else
+                           recent_ids = relation.reorder(created_at: :desc, id: :desc).limit(normalized_limit).select(:id)
+                           relation.where(id: recent_ids)
+                         end
+
+      limited_relation.ordered.preload(:participant)
+    end
+
+    def last_message_at
+      chat_messages.message.maximum(:created_at)
+    end
+
+    def active?(window: nil, at: Time.current)
+      message_time = last_message_at
+      return false if message_time.nil?
+
+      message_time >= at - self.class.activity_window_seconds(window)
+    end
+
+    def inactive?(window: nil, at: Time.current)
+      !active?(window: window, at: at)
+    end
+
+    def closed?
+      closed_at.present?
+    end
+
+    def opened?
+      !closed?
+    end
+
+    def close!(at: Time.current)
+      update!(closed_at: at)
+    end
+
+    def reopen!
+      update!(closed_at: nil)
+    end
+
+    def self.activity_window_seconds(window = nil)
+      value = window.nil? ? ChatGem.configuration.active_chat_window : window
+      seconds = value.to_i
+      return seconds if seconds.positive?
+
+      raise ArgumentError, "active chat window must be a positive duration"
+    end
+
+    private
+
+    def normalize_message_limit(limit)
+      return nil if limit.nil?
+
+      normalized = limit.to_i
+      return nil if normalized <= 0
+
+      normalized
+    end
+  end
+end

data/app/models/chat_gem/chat_membership.rb

@@ -0,0 +1,136 @@
+module ChatGem
+  class ChatMembership < ApplicationRecord
+    belongs_to :chat, class_name: "ChatGem::Chat", inverse_of: :chat_memberships
+    belongs_to :participant, polymorphic: true
+
+    enum :role, { member: 0, moderator: 1, admin: 2 }, default: :member
+
+    scope :active, lambda {
+      base_scope = where(removed_at: nil)
+      invitation_tracking_supported? ? base_scope.where(invitation_accepted: true) : base_scope
+    }
+    scope :pending, lambda {
+      return none unless invitation_tracking_supported?
+
+      where(removed_at: nil, invitation_accepted: false)
+    }
+
+    validates :participant_type, :participant_id, presence: true
+    validates :invitation_accepted, inclusion: { in: [true, false] }, if: :invitation_tracking_supported_for_record?
+    validate :enforce_chat_participant_limit, if: :active?
+    validate :custom_role_must_exist, if: -> { custom_role_key.present? }
+
+    before_validation :normalize_custom_role_key
+
+    class << self
+      def invitation_tracking_supported?
+        column_names.include?("invitation_accepted")
+      rescue ActiveRecord::StatementInvalid, ActiveRecord::NoDatabaseError
+        false
+      end
+    end
+
+    def active?
+      return removed_at.nil? unless self.class.invitation_tracking_supported?
+
+      removed_at.nil? && invitation_accepted?
+    end
+
+    def pending?
+      return false unless removed_at.nil?
+      return false unless self.class.invitation_tracking_supported?
+
+      !invitation_accepted?
+    end
+
+    def accept_invitation!
+      update_attributes = { muted: false, timed_out_until: nil }
+      update_attributes[:invitation_accepted] = true if self.class.invitation_tracking_supported?
+      update!(update_attributes)
+    end
+
+    def role_key
+      custom_role_key.presence || role
+    end
+
+    def role_key=(value)
+      normalized = normalize_role_key_value(value)
+      if normalized.blank?
+        self.custom_role_key = nil
+        return
+      end
+
+      if self.class.roles.key?(normalized)
+        self.role = normalized
+        self.custom_role_key = nil
+      else
+        self.role = :member if role.blank?
+        self.custom_role_key = normalized
+      end
+    end
+
+    def effective_role_key
+      role_key.to_s
+    end
+
+    def effective_role_definition
+      ChatGem.configuration.role_definition(effective_role_key)
+    end
+
+    def effective_role_name
+      definition = effective_role_definition
+      return effective_role_key.humanize if definition.nil?
+
+      definition[:name].presence || effective_role_key.humanize
+    end
+
+    def effective_role_rank
+      definition = effective_role_definition
+      return -1 if definition.nil?
+
+      definition[:rank].to_i
+    end
+
+    def effective_role_permissions
+      definition = effective_role_definition
+      return [] if definition.nil?
+
+      Array(definition[:permissions]).map(&:to_sym)
+    end
+
+    private
+
+    def invitation_tracking_supported_for_record?
+      self.class.invitation_tracking_supported?
+    end
+
+    def normalize_custom_role_key
+      self.custom_role_key = normalize_role_key_value(custom_role_key)
+    end
+
+    def custom_role_must_exist
+      return if ChatGem.configuration.role_definition(custom_role_key).present?
+
+      errors.add(:custom_role_key, "is not configured")
+    end
+
+    def normalize_role_key_value(value)
+      value.to_s.strip.presence
+    end
+
+    def enforce_chat_participant_limit
+      return if chat.nil?
+
+      limit = ChatGem.configuration.max_chat_participants
+      return if limit.nil?
+
+      limit = limit.to_i
+      return if limit <= 0
+
+      active_count_without_self = chat.chat_memberships.active.where.not(id: id).count
+      return if active_count_without_self < limit
+
+      errors.add(:chat, "has reached the participant limit (#{limit})")
+    end
+  end
+end