chat_sdk-telegram 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a2c77efea728df0e0f77552d2d709d7824f653e2137ae88678ddd7baa6b2415
-  data.tar.gz: 51854b5c55aacf5504e16a70e0f5120e188800572cd4da6eecc5bbd4ec205e28
+  metadata.gz: 3684daba2940e20bf967eb893864d9ada4e88c1829564c8d6707cacb3d2d70af
+  data.tar.gz: f570ad027ae3a715268b64cf817743cd74278da097ddfa52ece098baeb18c5bc
 SHA512:
-  metadata.gz: d222b99e2557c94c16465cff57e2858fb9aba5eda536446fee542502539414f76e9a55485b4706f5c8cedee6662325c7eb20c49e91059a37f67bc5a6a47c4de2
-  data.tar.gz: af031c32d6518ac316888941ebc34a216ad05ec3d847cbdee2a3e9cd7418d66157213a59cf0d29616f99c719990a3cb04aadfa441d8d94df3ed163ec7cd18090
+  metadata.gz: 42b0ab459cba54c49a4b7402fdb3481e55369b280f61c0e30857bb75bcc75774b68fed1bbea5d5877deb01f40f6e5ecdec15e30d5c7f6d27bda59792d6d5c304
+  data.tar.gz: 303379f0c56a05e2a11b82b3225a64f51791bd3d439ad55750015568afc4b3df955b66f376fd294b8d2d4c6187b89986529ff42c51d3c7fc6c13998f55681cdd

data/lib/chat_sdk/telegram/adapter.rb

@@ -10,10 +10,12 @@ module ChatSDK
 
       attr_reader :client
 
-      def initialize(bot_token: nil, secret_token: nil, bot_username: nil, allowed_user_ids: nil, allow_unverified_webhooks: nil)
+      def initialize(bot_token: nil, secret_token: nil, bot_username: nil, allowed_user_ids: nil, allow_unverified_webhooks: nil,
+        mention_on_reply: false)
         @bot_token = bot_token || ENV["TELEGRAM_BOT_TOKEN"]
         @secret_token = secret_token || ENV["TELEGRAM_WEBHOOK_SECRET_TOKEN"]
         @bot_username = bot_username || ENV["TELEGRAM_BOT_USERNAME"]
+        @mention_on_reply = mention_on_reply
         configured_user_ids = allowed_user_ids || ENV["TELEGRAM_ALLOWED_USER_IDS"]&.split(",")
         @allowed_user_ids = configured_user_ids&.map(&:to_s)&.to_set
         @allow_unverified_webhooks = if allow_unverified_webhooks.nil?
@@ -26,6 +28,7 @@ module ChatSDK
 
         @client = ApiClient.new(@bot_token)
         @renderer = KeyboardRenderer.new
+        @format_converter = FormatConverter.new
       end
 
       def name
@@ -62,7 +65,7 @@ module ChatSDK
         payload = read_json_body(rack_request)
         return [] unless allowed_user?(payload)
 
-        EventParser.parse(payload, bot_username: @bot_username)
+        EventParser.parse(payload, bot_username: @bot_username, mention_on_reply: @mention_on_reply)
       rescue JSON::ParserError
         []
       end
@@ -93,7 +96,7 @@ module ChatSDK
         parse_telegram_message(result, channel_id)
       end
 
-      def edit_message(channel_id:, message_id:, message:)
+      def edit_message(channel_id:, message_id:, message:, **_options)
         text, reply_markup = prepare_message_payload(message)
 
         @client.edit_message_text(
@@ -104,7 +107,7 @@ module ChatSDK
         )
       end
 
-      def delete_message(channel_id:, message_id:)
+      def delete_message(channel_id:, message_id:, **_options)
         @client.delete_message(chat_id: channel_id, message_id: message_id)
       end
 
@@ -118,7 +121,7 @@ module ChatSDK
         )
       end
 
-      def add_reaction(channel_id:, message_id:, emoji:)
+      def add_reaction(channel_id:, message_id:, emoji:, **_options)
         @client.set_message_reaction(
           chat_id: channel_id,
           message_id: message_id,
@@ -126,7 +129,7 @@ module ChatSDK
         )
       end
 
-      def remove_reaction(channel_id:, message_id:, emoji:) # rubocop:disable Lint/UnusedMethodArgument
+      def remove_reaction(channel_id:, message_id:, emoji:, **_options) # rubocop:disable Lint/UnusedMethodArgument
         @client.set_message_reaction(
           chat_id: channel_id,
           message_id: message_id,
@@ -151,7 +154,7 @@ module ChatSDK
         user_id
       end
 
-      def start_typing(channel_id:, thread_id: nil) # rubocop:disable Lint/UnusedMethodArgument
+      def start_typing(channel_id:, thread_id: nil, message_id: nil) # rubocop:disable Lint/UnusedMethodArgument
         @client.send_chat_action(chat_id: channel_id, action: "typing")
       end
 
@@ -178,7 +181,7 @@ module ChatSDK
             offset = update["update_id"] + 1
             next unless allowed_user?(update)
 
-            events = EventParser.parse(update, bot_username: @bot_username)
+            events = EventParser.parse(update, bot_username: @bot_username, mention_on_reply: @mention_on_reply)
             events.each { |event| block.call(event) }
           end
         end
@@ -207,7 +210,7 @@ module ChatSDK
           text = rendered[:text] if rendered[:text] && !rendered[:text].empty?
           reply_markup = rendered[:reply_markup]
         end
-        [text, reply_markup]
+        [@format_converter.truncate_markdown_v2(text, 4096), reply_markup]
       end
 
       def parse_telegram_message(data, channel_id)

data/lib/chat_sdk/telegram/event_parser.rb

@@ -4,7 +4,7 @@ module ChatSDK
   module Telegram
     class EventParser
       class << self
-        def parse(payload, bot_username: nil)
+        def parse(payload, bot_username: nil, mention_on_reply: false)
           return [] unless payload.is_a?(Hash)
 
           if payload["callback_query"]
@@ -12,7 +12,7 @@ module ChatSDK
           elsif payload["message_reaction"]
             parse_message_reaction(payload["message_reaction"])
           elsif payload["message"]
-            parse_message(payload["message"], bot_username: bot_username)
+            parse_message(payload["message"], bot_username: bot_username, mention_on_reply: mention_on_reply)
           else
             []
           end
@@ -20,7 +20,7 @@ module ChatSDK
 
         private
 
-        def parse_message(message, bot_username: nil)
+        def parse_message(message, bot_username: nil, mention_on_reply: false)
           return parse_bot_command(message, extract_user(message), message.dig("chat", "id")&.to_s, resolve_thread_id(message)) if bot_command?(message)
 
           user = extract_user(message)
@@ -28,6 +28,7 @@ module ChatSDK
           chat_type = message.dig("chat", "type")
           text = message["text"] || ""
           thread_id = resolve_thread_id(message)
+          reply_mention = reply_to_bot?(message, bot_username, mention_on_reply)
 
           msg = ChatSDK::Message.new(
             id: message["message_id"]&.to_s,
@@ -36,11 +37,12 @@ module ChatSDK
             thread_id: thread_id,
             channel_id: chat_id,
             platform: :telegram,
+            is_mention: reply_mention ? true : nil,
             reply_to: build_reply_to(message["reply_to_message"], chat_id),
             raw: message
           )
 
-          event_class = if mention?(text, bot_username)
+          event_class = if mention?(text, bot_username) || reply_mention
             ChatSDK::Events::Mention
           elsif chat_type == "private"
             ChatSDK::Events::DirectMessage
@@ -149,6 +151,18 @@ module ChatSDK
           /(?<!\w)@#{Regexp.escape(bot_username)}(?![\w-])/i.match?(text)
         end
 
+        def reply_to_bot?(message, bot_username, mention_on_reply)
+          return false unless mention_on_reply && bot_username
+
+          reply = message["reply_to_message"] || {}
+          bot_user = reply["from"] || {}
+          return false unless bot_user["is_bot"] && bot_user["username"].to_s.casecmp?(bot_username)
+
+          topic_root_reply = message["is_topic_message"] &&
+            reply["message_id"].to_s == message["message_thread_id"].to_s
+          !topic_root_reply
+        end
+
         def build_reply_to(reply, chat_id)
           return unless reply
 

data/lib/chat_sdk/telegram/format_converter.rb

@@ -33,8 +33,156 @@ module ChatSDK
         parts.map.with_index { |part, i| i.odd? ? part : escape_special_chars(part) }.join
       end
 
+      def truncate_markdown_v2(text, limit)
+        text = text.to_s
+        return text if text.length <= limit
+
+        ellipsis = "\\.\\.\\."
+        slice = text[0, limit - ellipsis.length]
+        "#{trim_to_safe_boundary(slice)}#{ellipsis}"
+      end
+
       private
 
+      def trim_to_safe_boundary(text)
+        text = text[0...-1] while trailing_backslashes(text).odd?
+        link_detection_text, = mask_code_spans(text)
+        link_start = incomplete_link_start(link_detection_text)
+        text = text[0...link_start] if link_start
+
+        masked_links = mask_links(text)
+        masked, incomplete_code_start = mask_code_spans(masked_links)
+        text = text[0...incomplete_code_start] if incomplete_code_start
+        return text unless incomplete_code_start.nil?
+
+        marker_positions = Hash.new { |hash, key| hash[key] = [] }
+        chars = masked.chars
+        index = 0
+        while index < chars.length
+          if chars[index] == "\\"
+            index += 2
+            next
+          end
+          if %w[* _ ~ |].include?(chars[index])
+            run_length = 1
+            run_length += 1 while chars[index + run_length] == chars[index]
+            marker_positions[[chars[index], run_length]] << index
+            index += run_length
+          else
+            index += 1
+          end
+        end
+
+        cut = marker_positions.values
+          .select { |positions| positions.length.odd? }
+          .map(&:last)
+          .min
+        cut ? text[0...cut] : text
+      end
+
+      def trailing_backslashes(text)
+        text[/\\+\z/].to_s.length
+      end
+
+      def incomplete_link_start(text)
+        chars = text.chars
+        openings = []
+        index = 0
+        while index < chars.length
+          if chars[index] == "\\"
+            index += 2
+            next
+          elsif chars[index] == "["
+            openings << index
+          elsif chars[index] == "]" && !openings.empty?
+            opening = openings.pop
+            if chars[index + 1] == "("
+              closing = index + 2
+              closing += 1 while closing < chars.length &&
+                  (chars[closing] != ")" || escaped_at?(chars, closing))
+              return opening if closing == chars.length
+            end
+          end
+          index += 1
+        end
+        openings.last
+      end
+
+      def mask_code_spans(text)
+        chars = text.chars
+        masked = chars.dup
+        index = 0
+        while index < chars.length
+          if chars[index] == "\\"
+            index += 2
+            next
+          end
+          unless chars[index] == "`"
+            index += 1
+            next
+          end
+
+          run_length = 1
+          run_length += 1 while chars[index + run_length] == "`"
+          closing = index + run_length
+          while closing < chars.length
+            if chars[closing] == "`"
+              candidate_run_length = backtick_run_length(chars, closing)
+              break if candidate_run_length == run_length
+
+              closing += candidate_run_length
+            else
+              closing += 1
+            end
+          end
+          return [masked.join, index] if closing >= chars.length
+
+          closing_end = closing + run_length
+          (index...closing_end).each { |position| masked[position] = " " }
+          index = closing_end
+        end
+        [masked.join, nil]
+      end
+
+      def mask_links(text)
+        chars = text.chars
+        masked = chars.dup
+        openings = []
+        index = 0
+        while index < chars.length
+          if chars[index] == "\\"
+            index += 2
+            next
+          elsif chars[index] == "["
+            openings << index
+          elsif chars[index] == "]" && !openings.empty? && chars[index + 1] == "("
+            opening = openings.pop
+            closing = index + 2
+            closing += 1 while closing < chars.length &&
+                (chars[closing] != ")" || escaped_at?(chars, closing))
+            if closing < chars.length
+              (opening..closing).each { |position| masked[position] = " " }
+              index = closing
+            end
+          end
+          index += 1
+        end
+        masked.join
+      end
+
+      def backtick_run_length(chars, index)
+        length = 1
+        length += 1 while chars[index + length] == "`"
+        length
+      end
+
+      def escaped_at?(chars, index)
+        backslashes = 0
+        backslashes += 1 while index - backslashes - 1 >= 0 &&
+            chars[index - backslashes - 1] == "\\"
+        backslashes.odd?
+      end
+
       # Escape Telegram MarkdownV2 special chars outside of markdown syntax.
       # Preserves bold (**), italic (*), strikethrough (~~), links, etc.
       def escape_special_chars(text)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chat_sdk-telegram
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Quentin Rousseau
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement