grammerb 0.1.0-x86_64-linux

data/lib/grammerb/conversation.rb

@@ -0,0 +1,81 @@
+# lib/grammerb/conversation.rb
+require "set"
+
+module Grammerb
+  class Conversation
+    class TimeoutError < Errors::Error; end
+
+    attr_reader :chat_id
+
+    def initialize(client, chat_id, timeout: 60)
+      @client = client
+      @chat_id = chat_id
+      @default_timeout = timeout
+      @queue = Queue.new
+      @last_outgoing_id = nil
+      @outgoing_ids = Set.new
+    end
+
+    # Send a message in this conversation.
+    def send_message(text, **opts)
+      msg = @client.send_message(@chat_id, text, **opts)
+      @last_outgoing_id = msg.id
+      @outgoing_ids.add(msg.id)
+      msg
+    end
+
+    # Wait for the next incoming message.
+    def get_response(timeout: nil)
+      wait_event(Events::NewMessage, timeout: timeout)
+    end
+
+    # Wait for a message edit.
+    def get_edit(timeout: nil)
+      wait_event(Events::MessageEdited, timeout: timeout)
+    end
+
+    # Wait for a callback query (button press).
+    def get_callback(timeout: nil)
+      wait_event(Events::CallbackQuery, timeout: timeout)
+    end
+
+    # Wait for any event matching the given class.
+    # Automatically skips messages sent by this conversation.
+    def wait_event(event_class, timeout: nil)
+      t = timeout || @default_timeout
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + t
+
+      loop do
+        remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        raise TimeoutError, "Conversation timed out after #{t}s" if remaining <= 0
+
+        event = @queue.pop(timeout: remaining)
+        raise TimeoutError, "Conversation timed out after #{t}s" if event.nil?
+
+        next unless event.is_a?(event_class)
+
+        # Skip our own outgoing messages
+        if event.respond_to?(:message_id) && @outgoing_ids.include?(event.message_id)
+          next
+        end
+
+        return event
+      end
+    end
+
+    # Mark conversation as read up to last received message.
+    def mark_read
+      @client.mark_as_read(@chat_id)
+    end
+
+    # Cancel the conversation early (drains the queue).
+    def cancel
+      @queue.close
+    end
+
+    # @api private — called by the event dispatch system.
+    def _push(event)
+      @queue.push(event) unless @queue.closed?
+    end
+  end
+end

data/lib/grammerb/errors.rb

@@ -0,0 +1,108 @@
+# lib/grammerb/errors.rb
+module Grammerb
+  module Errors
+    class Error < StandardError; end
+    class ConnectionError < Error; end
+    class AuthError < Error; end
+    class NotConnectedError < Error; end
+
+    # Telegram-specific errors
+    class RPCError < Error
+      attr_reader :code, :message_text, :value
+
+      def initialize(code, message_text = nil, value: nil)
+        @code = code
+        @message_text = message_text
+        @value = value
+        super("RPCError #{code}: #{message_text}")
+      end
+    end
+
+    class FloodWait < RPCError
+      attr_reader :seconds
+
+      def initialize(seconds)
+        @seconds = seconds
+        super(420, "FLOOD_WAIT", value: seconds)
+      end
+    end
+
+    class UserNotFound < RPCError
+      def initialize
+        super(400, "USER_NOT_FOUND")
+      end
+    end
+
+    class ChatWriteForbidden < RPCError
+      def initialize
+        super(403, "CHAT_WRITE_FORBIDDEN")
+      end
+    end
+
+    class PhoneNumberInvalid < RPCError
+      def initialize
+        super(400, "PHONE_NUMBER_INVALID")
+      end
+    end
+
+    class SessionPasswordNeeded < RPCError
+      def initialize
+        super(401, "SESSION_PASSWORD_NEEDED")
+      end
+    end
+
+    # Map RPC error name strings to classes
+    RPC_MAP = {
+      "FLOOD_WAIT" => FloodWait,
+      "USER_NOT_FOUND" => UserNotFound,
+      "CHAT_WRITE_FORBIDDEN" => ChatWriteForbidden,
+      "PHONE_NUMBER_INVALID" => PhoneNumberInvalid,
+      "SESSION_PASSWORD_NEEDED" => SessionPasswordNeeded,
+    }.freeze
+
+    # Map kind strings to exception classes
+    KIND_MAP = {
+      "flood_wait" => FloodWait,
+      "connection" => ConnectionError,
+      "auth" => AuthError,
+      "not_connected" => NotConnectedError,
+      "rpc" => RPCError,
+    }.freeze
+
+    # Parse a structured error string from the native extension.
+    # Format: "kind:code:name:value|Human-readable message"
+    def self.from_native(msg)
+      if msg =~ /\A(\w+):(\d+):([^:]*):([^|]*)\|(.+)\z/m
+        kind, code, name, value_str, human = $1, $2.to_i, $3, $4, $5
+
+        case kind
+        when "flood_wait"
+          FloodWait.new(value_str.to_i)
+        when "connection"
+          ConnectionError.new(human)
+        when "auth"
+          AuthError.new(human)
+        when "not_connected"
+          NotConnectedError.new(human)
+        when "rpc"
+          # Check if we have a specific class for this RPC error name
+          if (klass = RPC_MAP[name])
+            if klass == FloodWait
+              klass.new(value_str.to_i)
+            else
+              klass.new
+            end
+          else
+            RPCError.new(code, name, value: value_str.empty? ? nil : value_str.to_i)
+          end
+        else
+          Error.new(human)
+        end
+      else
+        # Unstructured message — wrap in base error
+        Error.new(msg)
+      end
+    end
+
+  end
+end

data/lib/grammerb/events.rb

@@ -0,0 +1,438 @@
+# lib/grammerb/events.rb
+module Grammerb
+  module Events
+    class Event
+      attr_reader :raw
+      attr_accessor :client
+
+      def initialize(raw)
+        @raw = raw
+      end
+    end
+
+    # Shared logic for message-like events (NewMessage, MessageEdited).
+    module MessageEvent
+      attr_reader :message_id, :text, :chat_id, :chat_name,
+                  :sender_id, :sender_name, :date, :sender_is_bot, :chat_type,
+                  :grouped_id, :reply_to_message_id,
+                  :media_type, :media_id, :media_file_name, :media_mime_type, :media_size,
+                  :buttons
+
+      def init_message_fields(raw)
+        @message_id = raw[:message_id]
+        @text = raw[:message_text]
+        @chat_id = raw[:chat_id]
+        @chat_name = raw[:chat_name]
+        @sender_id = raw[:sender_id]
+        @sender_name = raw[:sender_name]
+        @date = raw[:date] ? Time.at(raw[:date]) : nil
+        @sender_is_bot = raw[:sender_is_bot]
+        @chat_type = raw[:chat_type]
+        @grouped_id = raw[:grouped_id]
+        @reply_to_message_id = raw[:reply_to_message_id]
+        @media_type = raw[:media_type]
+        @media_id = raw[:media_id]
+        @media_file_name = raw[:media_file_name]
+        @media_mime_type = raw[:media_mime_type]
+        @media_size = raw[:media_size]
+        @buttons = raw[:buttons]&.map { |row| row.map { |b| Types::Button.new(b) } }
+      end
+
+      def album?
+        !@grouped_id.nil?
+      end
+
+      def has_media?
+        !@media_type.nil?
+      end
+
+      def photo?
+        @media_type == "photo"
+      end
+
+      def document?
+        @media_type == "document"
+      end
+
+      def sticker?
+        @media_type == "sticker"
+      end
+
+      def has_buttons?
+        @buttons && !@buttons.empty?
+      end
+
+      def edit(text, parse_mode: nil, buttons: nil, reply_markup: nil)
+        @client&.edit_message(chat_id || chat_name, message_id, text, parse_mode: parse_mode, buttons: buttons, reply_markup: reply_markup)
+      end
+
+      def delete
+        @client&.delete_messages(chat_id || chat_name, message_id)
+      end
+
+      def bot?
+        @sender_is_bot == true
+      end
+
+      def private?
+        @chat_type == "user"
+      end
+
+      def group?
+        @chat_type == "chat"
+      end
+
+      def channel?
+        @chat_type == "channel"
+      end
+    end
+
+    class NewMessage < Event
+      include MessageEvent
+
+      def initialize(raw)
+        super
+        init_message_fields(raw)
+      end
+
+      def reply(text, **opts)
+        @client&.send_message(chat_id || chat_name, text, reply_to: message_id, **opts)
+      end
+
+      def respond(text, **opts)
+        @client&.send_message(chat_id || chat_name, text, **opts)
+      end
+
+      def forward(to_chat)
+        @client&.forward_messages(chat_id || chat_name, [message_id], to_chat)
+      end
+    end
+
+    class MessageEdited < Event
+      include MessageEvent
+
+      def initialize(raw)
+        super
+        init_message_fields(raw)
+      end
+    end
+
+    class MessageDeleted < Event
+      attr_reader :deleted_ids, :chat_id
+
+      def initialize(raw)
+        super
+        @deleted_ids = raw[:deleted_message_ids] || []
+        @chat_id = raw[:chat_id]
+      end
+    end
+
+    class CallbackQuery < Event
+      attr_reader :query_id, :data, :chat_id, :sender_id, :message_id
+
+      def initialize(raw)
+        super
+        @query_id = raw[:callback_query_id]
+        @data = raw[:callback_data]
+        @chat_id = raw[:callback_chat_id]
+        @sender_id = raw[:sender_id]
+        @message_id = raw[:message_id]
+      end
+
+      def data_str
+        @data_str_cache ||= @data&.pack("C*")&.force_encoding("UTF-8")
+      end
+
+      def answer(text: nil, alert: false, cache_time: nil)
+        @client&.answer_callback_query(query_id, text: text, alert: alert, cache_time: cache_time)
+      end
+
+      def edit(text, parse_mode: nil, buttons: nil, reply_markup: nil)
+        @client&.edit_message(chat_id, message_id, text, parse_mode: parse_mode, buttons: buttons, reply_markup: reply_markup)
+      end
+
+      def delete
+        @client&.delete_messages(chat_id, message_id)
+      end
+
+      def reply(text, **opts)
+        @client&.send_message(chat_id, text, reply_to: message_id, **opts)
+      end
+
+      def respond(text, **opts)
+        @client&.send_message(chat_id, text, **opts)
+      end
+    end
+
+    class InlineQuery < Event
+      attr_reader :query_id, :query, :offset, :sender_id
+
+      def initialize(raw)
+        super
+        @query_id = raw[:inline_query_id]
+        @query = raw[:inline_query_text]
+        @offset = raw[:inline_query_offset]
+        @sender_id = raw[:sender_id]
+      end
+
+      def answer(results, cache_time: nil, is_personal: false, next_offset: nil)
+        @client&.answer_inline_query(query_id, results, cache_time: cache_time, is_personal: is_personal, next_offset: next_offset)
+      end
+    end
+
+    class UpdateError < Event
+      attr_reader :message
+
+      def initialize(raw)
+        super
+        @message = raw[:message_text]
+      end
+    end
+
+    class InlineSend < Event
+      attr_reader :sender_id, :query, :result_id
+
+      def initialize(raw)
+        super
+        @sender_id = raw[:sender_id]
+        @query = raw[:inline_send_query]
+        @result_id = raw[:inline_send_result_id]
+      end
+    end
+
+    class PreCheckoutQuery < Event
+      attr_reader :query_id, :sender_id, :currency, :total_amount, :invoice_payload
+
+      def initialize(raw)
+        super
+        @query_id = raw[:pre_checkout_query_id]
+        @sender_id = raw[:sender_id]
+        @currency = raw[:pre_checkout_currency]
+        @total_amount = raw[:pre_checkout_amount]
+        @invoice_payload = raw[:pre_checkout_payload]
+      end
+
+      def approve
+        @client&.answer_pre_checkout_query(query_id, ok: true)
+      end
+
+      def reject(error_message = "Payment rejected")
+        @client&.answer_pre_checkout_query(query_id, ok: false, error_message: error_message)
+      end
+    end
+
+    class SuccessfulPayment < Event
+      attr_reader :sender_id, :currency, :total_amount, :invoice_payload, :charge_id
+
+      def initialize(raw)
+        super
+        @sender_id = raw[:sender_id]
+        @currency = raw[:payment_currency]
+        @total_amount = raw[:payment_amount]
+        @invoice_payload = raw[:payment_payload]
+        @charge_id = raw[:payment_charge_id]
+      end
+    end
+
+    class Album < Event
+      attr_reader :messages, :grouped_id, :chat_id, :chat_name
+
+      def initialize(messages)
+        super(messages.first.raw)
+        @messages = messages
+        @grouped_id = messages.first.grouped_id
+        @chat_id = messages.first.chat_id
+        @chat_name = messages.first.chat_name
+      end
+
+      def texts
+        @messages.map(&:text)
+      end
+
+      def reply(text, **opts)
+        @client&.send_message(chat_id || chat_name, text, reply_to: messages.first.message_id, **opts)
+      end
+
+      def respond(text, **opts)
+        @client&.send_message(chat_id || chat_name, text, **opts)
+      end
+    end
+
+    class ChatAction < Event
+      attr_reader :action_type, :message_id, :chat_id, :chat_name, :chat_type,
+                  :sender_id, :actor_id, :user_ids, :new_title,
+                  :pinned_message_id, :game_score, :date
+
+      def initialize(raw)
+        super
+        @action_type = raw[:action_type]
+        @message_id = raw[:message_id]
+        @chat_id = raw[:chat_id]
+        @chat_name = raw[:chat_name]
+        @chat_type = raw[:chat_type]
+        @sender_id = raw[:sender_id]
+        @actor_id = raw[:actor_id]
+        @user_ids = raw[:action_user_ids] || []
+        @new_title = raw[:new_title]
+        @pinned_message_id = raw[:pinned_message_id]
+        @game_score = raw[:game_score]
+        @date = raw[:date] ? Time.at(raw[:date]) : nil
+      end
+
+      def user_joined?;     @action_type == "user_joined" end
+      def user_added?;      @action_type == "user_added" end
+      def user_kicked?;     @action_type == "user_kicked" end
+      def user_left?;       @action_type == "user_left" end
+      def title_changed?;   @action_type == "title_changed" end
+      def photo_changed?;   @action_type == "photo_changed" end
+      def photo_deleted?;   @action_type == "photo_deleted" end
+      def pin_message?;     @action_type == "pin_message" end
+      def unpin?;           @action_type == "unpin" end
+      def chat_created?;    @action_type == "chat_created" end
+      def channel_created?; @action_type == "channel_created" end
+      def user_promoted?;   @action_type == "user_promoted" end
+      def user_demoted?;    @action_type == "user_demoted" end
+      def new_score?;       @action_type == "new_score" end
+
+      def user_id;  @user_ids&.first end
+      def added_by; @actor_id if user_added? end
+      def kicked_by; @actor_id if user_kicked? end
+
+      def reply(text, **opts)
+        @client&.send_message(chat_id || chat_name, text, reply_to: message_id, **opts)
+      end
+
+      def respond(text, **opts)
+        @client&.send_message(chat_id || chat_name, text, **opts)
+      end
+
+      def delete
+        @client&.delete_messages(chat_id || chat_name, message_id) if message_id
+      end
+    end
+
+    class UserUpdate < Event
+      attr_reader :sender_id, :chat_id, :user_status,
+                  :last_seen, :online_until, :typing_action
+
+      def initialize(raw)
+        super
+        @sender_id = raw[:sender_id]
+        @chat_id = raw[:chat_id]
+        @user_status = raw[:user_status]
+        @last_seen = raw[:last_seen] ? Time.at(raw[:last_seen]) : nil
+        @online_until = raw[:online_until] ? Time.at(raw[:online_until]) : nil
+        @typing_action = raw[:typing_action]
+      end
+
+      def online?;        @user_status == "online" end
+      def offline?;       @user_status == "offline" end
+      def recently?;      @user_status == "recently" end
+      def within_weeks?;  @user_status == "last_week" end
+      def within_months?; @user_status == "last_month" end
+
+      def typing?;    @typing_action == "typing" end
+      def recording?; @typing_action&.start_with?("recording") end
+      def uploading?; @typing_action&.start_with?("uploading") end
+      def playing?;   @typing_action == "playing_game" end
+      def cancel?;    @typing_action == "cancel" end
+      def audio?;     @typing_action&.include?("audio") end
+      def video?;     @typing_action&.include?("video") && !round? end
+      def round?;     @typing_action&.include?("round") end
+      def document?;  @typing_action == "uploading_document" end
+      def photo?;     @typing_action == "uploading_photo" end
+      def sticker?;   @typing_action == "choosing_sticker" end
+      def contact?;   @typing_action == "choosing_contact" end
+      def geo?;       @typing_action == "geo_location" end
+
+      alias_method :user_id, :sender_id
+    end
+
+    class MessageRead < Event
+      attr_reader :chat_id, :max_id, :outbox, :unread_count, :message_ids
+
+      def initialize(raw)
+        super
+        @chat_id = raw[:chat_id]
+        @max_id = raw[:max_id]
+        @outbox = raw[:is_outbox] || false
+        @unread_count = raw[:unread_count]
+        @message_ids = raw[:read_message_ids] || []
+      end
+
+      def inbox?;  !@outbox end
+      def outbox?; @outbox end
+      def contents?; !@message_ids.empty? end
+
+      def is_read?(message_id)
+        if contents?
+          @message_ids.include?(message_id)
+        elsif @max_id
+          message_id <= @max_id
+        else
+          false
+        end
+      end
+
+      def get_messages
+        return [] unless @client && @chat_id
+        ids = contents? ? @message_ids : (@max_id ? [@max_id] : [])
+        return [] if ids.empty?
+        @client.get_messages_by_id(@chat_id, *ids).compact
+      end
+    end
+
+    class RawUpdate < Event; end
+
+    # Maps update type strings from Rust to event classes
+    TYPE_MAP = {
+      "new_message" => NewMessage,
+      "message_edited" => MessageEdited,
+      "message_deleted" => MessageDeleted,
+      "callback_query" => CallbackQuery,
+      "inline_query" => InlineQuery,
+      "inline_send" => InlineSend,
+      "pre_checkout_query" => PreCheckoutQuery,
+      "successful_payment" => SuccessfulPayment,
+      "chat_action" => ChatAction,
+      "user_update" => UserUpdate,
+      "message_read" => MessageRead,
+      "raw" => RawUpdate,
+      "error" => UpdateError,
+    }.freeze
+
+    def self.from_raw(raw_hash)
+      type_str = raw_hash[:type]
+      klass = TYPE_MAP[type_str]
+      return nil unless klass
+      klass.new(raw_hash)
+    end
+
+    # Handler registration
+    class Handler
+      attr_reader :event_class, :pattern, :chats, :block
+
+      def initialize(event_class, pattern: nil, chats: nil, &block)
+        @event_class = event_class
+        @pattern = pattern
+        @chats = chats
+        @block = block
+      end
+
+      def matches?(event)
+        return false unless event.is_a?(@event_class)
+        if @pattern && event.respond_to?(:text)
+          text = event.text
+          # Skip pattern check for media-only messages (nil text) instead of rejecting them
+          return false if text && !text.match?(@pattern)
+        end
+        if @chats
+          chat_id = event.respond_to?(:chat_id) ? event.chat_id : nil
+          chat_name = event.respond_to?(:chat_name) ? event.chat_name : nil
+          return false unless (chat_name && @chats.include?(chat_name)) || (chat_id && @chats.include?(chat_id))
+        end
+        true
+      end
+    end
+  end
+end