gruubY 0.2.0

data/lib/grubY/client.rb

@@ -0,0 +1,296 @@
+require_relative "bot"
+require_relative "group_manager"
+require_relative "handlers"
+require_relative "filters"
+require_relative "types/message"
+require_relative "types/chat"
+require_relative "types/user"
+
+module GrubY
+  class Client
+    attr_reader :bot, :api, :session, :group_manager
+
+    def initialize(token, session: Session.new, polling_timeout: 30)
+      @bot = Bot.new(token, session: session)
+      @api = @bot.api
+      @session = session
+      @group_manager = GroupManager.new(@api, session: @session)
+      @polling_timeout = polling_timeout
+      @polling_thread = nil
+      @running = false
+    end
+
+    def start
+      return if @running
+
+      @bot.emit(:connect)
+      @running = true
+      start_polling
+      @bot.emit(:start)
+      self
+    end
+
+    def stop
+      @bot.emit(:stop) if @running
+      @running = false
+      @polling_thread&.kill
+      @polling_thread = nil
+      @bot.emit(:disconnect)
+      self
+    end
+
+    def restart
+      stop
+      start
+    end
+
+    def connect
+      start
+    end
+
+    def disconnect
+      stop
+    end
+
+    def run
+      start
+      idle
+      stop
+    end
+
+    def terminate
+      stop
+    end
+
+    def add_handler(handler_or_event, filter=nil, group: 0, &block)
+      if handler_or_event.is_a?(GrubY::Handlers::BaseHandler)
+        register_handler_object(handler_or_event)
+      else
+        @bot.on(handler_or_event, filter, group: group, &block)
+      end
+    end
+
+    def remove_handler(event, handler_id = nil, &block)
+      @bot.remove_handler(event, handler_id, &block)
+    end
+
+    def on(event, filter=nil, &block)
+      add_handler(event, filter, &block)
+    end
+
+    {
+      on_message: GrubY::Handlers::MessageHandler,
+      on_edited_message: GrubY::Handlers::EditedMessageHandler,
+      on_business_message: GrubY::Handlers::BusinessMessageHandler,
+      on_edited_business_message: GrubY::Handlers::EditedBusinessMessageHandler,
+      on_deleted_messages: GrubY::Handlers::DeletedMessagesHandler,
+      on_deleted_business_messages: GrubY::Handlers::DeletedBusinessMessagesHandler,
+      on_message_reaction_count: GrubY::Handlers::MessageReactionCountHandler,
+      on_message_reaction: GrubY::Handlers::MessageReactionHandler,
+      on_business_connection: GrubY::Handlers::BusinessConnectionHandler,
+      on_story: GrubY::Handlers::StoryHandler,
+      on_callback_query: GrubY::Handlers::CallbackQueryHandler,
+      on_chat_boost: GrubY::Handlers::ChatBoostHandler,
+      on_chat_join_request: GrubY::Handlers::ChatJoinRequestHandler,
+      on_chat_member_updated: GrubY::Handlers::ChatMemberUpdatedHandler,
+      on_chosen_inline_result: GrubY::Handlers::ChosenInlineResultHandler,
+      on_inline_query: GrubY::Handlers::InlineQueryHandler,
+      on_poll: GrubY::Handlers::PollHandler,
+      on_pre_checkout_query: GrubY::Handlers::PreCheckoutQueryHandler,
+      on_purchased_paid_media: GrubY::Handlers::PurchasedPaidMediaHandler,
+      on_shipping_query: GrubY::Handlers::ShippingQueryHandler,
+      on_user_status: GrubY::Handlers::UserStatusHandler,
+      on_start: GrubY::Handlers::StartHandler,
+      on_stop: GrubY::Handlers::StopHandler,
+      on_connect: GrubY::Handlers::ConnectHandler,
+      on_disconnect: GrubY::Handlers::DisconnectHandler,
+      on_managed_bot: GrubY::Handlers::ManagedBotUpdatedHandler,
+      on_raw_update: GrubY::Handlers::RawUpdateHandler
+    }.each do |decorator_name, klass|
+      define_method(decorator_name) do |filters = nil, group: 0, &block|
+        add_handler(klass.new(block, filters: filters, group: group))
+      end
+    end
+
+    def on_error(exceptions = nil, filters = nil, group: 0, &block)
+      add_handler(
+        GrubY::Handlers::ErrorHandler.new(
+          block,
+          filters: filters,
+          group: group,
+          exceptions: exceptions
+        )
+      )
+    end
+
+    def use(&block)
+      @bot.use(&block)
+    end
+
+    def use_plugin(path)
+      @bot.use_plugin(path)
+    end
+
+    def process_update(update)
+      @bot.process_update(update)
+    end
+
+    def stop_transmission
+      true
+    end
+
+    def export_session_string
+      @session.to_h.to_json
+    end
+
+    def set_parse_mode(mode)
+      @session.set("__parse_mode__", mode.to_s)
+      mode
+    end
+
+    def get_parse_mode
+      @session.get("__parse_mode__")
+    end
+
+    def set_dc(dc_id, config = {})
+      @session.set("dc:#{dc_id}", config)
+      config
+    end
+
+    def get_dc_option(dc_id)
+      @session.get("dc:#{dc_id}")
+    end
+
+    def get_session
+      @session
+    end
+
+    def get_file(file_id)
+      @api.get_file(file_id)
+    end
+
+    def build_message(data)
+      GrubY::Message.new(data, api: @api, client: self)
+    end
+
+    def build_chat(data)
+      GrubY::Chat.new(data, api: @api, client: self)
+    end
+
+    def build_user(data)
+      GrubY::User.new(data, api: @api, client: self)
+    end
+
+    def idle
+      @idle = true
+      trap_signals
+      sleep 0.3 while @idle
+    ensure
+      @idle = false
+    end
+
+    def self.compose(*clients, &block)
+      clients.each(&:start)
+      block.call if block
+      clients.each(&:idle)
+    ensure
+      clients.each(&:stop)
+    end
+
+    [
+      :send_message, :forward_message, :forward_messages, :forward_media_group,
+      :copy_message, :copy_messages, :copy_media_group, :send_photo, :send_audio,
+      :send_document, :send_video, :send_animation, :send_voice, :send_video_note,
+      :send_media_group, :send_paid_media, :send_location, :send_venue,
+      :send_contact, :send_poll, :send_checklist, :send_dice, :send_message_draft,
+      :send_chat_action, :set_message_reaction, :send_reaction,
+      :answer_callback_query, :edit_message_text, :delete_message,
+      :delete_messages, :get_updates, :download_file
+    ].each do |api_method|
+      define_method(api_method) do |*args, **kwargs|
+        @api.public_send(api_method, *args, **kwargs)
+      end
+    end
+
+    def method_missing(name, *args, **kwargs, &block)
+      return super unless @api.respond_to?(name)
+
+      @api.public_send(name, *args, **kwargs, &block)
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @api.respond_to?(name) || super
+    end
+
+    private
+
+    def register_handler_object(handler)
+      wrapped = proc do |ctx|
+        payload = handler.extract(ctx)
+        if handler.filters
+          next unless handler.filters.call(handler, self, payload)
+        end
+
+        if handler.is_a?(GrubY::Handlers::ErrorHandler)
+          error = payload
+          allowed = Array(handler.exceptions).compact
+          next if !allowed.empty? && !allowed.any? { |klass| error.is_a?(klass) }
+          invoke_handler_callback(handler.callback, error, ctx)
+        else
+          invoke_handler_callback(handler.callback, payload, ctx)
+        end
+      end
+
+      @bot.on(handler.event, nil, group: handler.group, &wrapped)
+    end
+
+    def invoke_handler_callback(callback, payload, ctx)
+      return unless callback
+      if payload.nil? && ctx.update.is_a?(Hash) && ctx.update.empty?
+        case callback.arity
+        when 0 then callback.call
+        when 1 then callback.call(self)
+        else callback.call(self, nil, ctx)
+        end
+        return
+      end
+
+      case callback.arity
+      when 0
+        callback.call
+      when 1
+        callback.call(payload)
+      when 2
+        callback.call(self, payload)
+      else
+        callback.call(self, payload, ctx)
+      end
+    end
+
+    def start_polling
+      offset = nil
+      @polling_thread = Thread.new do
+        while @running
+          begin
+            updates = @api.get_updates(offset, timeout: @polling_timeout) || []
+            updates.each do |update|
+              offset = update["update_id"].to_i + 1
+              process_update(update)
+            end
+          rescue => e
+            @bot.emit(:error, { "error" => e })
+            warn "[CLIENT] polling error: #{e.class}: #{e.message}"
+            sleep 1
+          end
+        end
+      end
+    end
+
+    def trap_signals
+      %w[INT TERM].each do |sig|
+        Signal.trap(sig) { @idle = false }
+      rescue ArgumentError
+      end
+    end
+  end
+end

data/lib/grubY/context.rb

@@ -0,0 +1,242 @@
+require_relative "types/user"
+require_relative "file_stream"
+require_relative "types/message"
+require_relative "types/bound_entities"
+require_relative "types/base_object"
+
+module GrubY
+  class Context
+    attr_reader :update, :api, :session
+
+    def initialize(update, api, session = nil)
+      @update = update
+      @api = api
+      @session = session
+    end
+
+    def message
+      data = primary_message_payload
+      Message.new(data, api: @api) if data
+    end
+
+    def edited_message
+      data = @update["edited_message"]
+      Message.new(data, api: @api) if data
+    end
+
+    def business_message
+      data = @update["business_message"]
+      Message.new(data, api: @api) if data
+    end
+
+    def edited_business_message
+      data = @update["edited_business_message"]
+      Message.new(data, api: @api) if data
+    end
+
+    def deleted_messages
+      list = @update["deleted_messages"]
+      Array(list).map { |m| Message.new(m, api: @api) }
+    end
+
+    def deleted_business_messages
+      list = @update["deleted_business_messages"]
+      Array(list).map { |m| Message.new(m, api: @api) }
+    end
+
+    def text
+      primary_message_payload&.dig("text")
+    end
+
+    def chat_id
+      primary_message_payload&.dig("chat", "id")
+    end
+
+    def from
+      data = user_data
+      User.new(data, api: @api) if data
+    end
+
+    def poll(question, options)
+      @api.send_poll(chat_id, question, options)
+    end
+
+    def callback_query
+      data = update["callback_query"]
+      CallbackQuery.new(data, api: @api) if data
+    end
+
+    def inline_query
+      data = update["inline_query"]
+      InlineQuery.new(data, api: @api) if data
+    end
+
+    def pre_checkout_query
+      data = update["pre_checkout_query"]
+      PreCheckoutQuery.new(data, api: @api) if data
+    end
+
+    def shipping_query
+      data = update["shipping_query"]
+      ShippingQuery.new(data, api: @api) if data
+    end
+
+    def chat_join_request
+      data = update["chat_join_request"]
+      ChatJoinRequest.new(data, api: @api) if data
+    end
+
+    def business_connection
+      data = @update["business_connection"]
+      wrap_type("BusinessConnection", data)
+    end
+
+    def message_reaction_count
+      data = @update["message_reaction_count"] || @update["message_reaction_count_updated"]
+      wrap_type("MessageReactionCountUpdated", data)
+    end
+
+    def message_reaction
+      data = @update["message_reaction"] || @update["message_reaction_updated"]
+      wrap_type("MessageReactionUpdated", data)
+    end
+
+    def chat_boost
+      data = @update["chat_boost"] || @update["chat_boost_updated"]
+      wrap_type("ChatBoostUpdated", data)
+    end
+
+    def chat_member_updated
+      data = @update["chat_member_updated"] || @update["chat_member"]
+      wrap_type("ChatMemberUpdated", data)
+    end
+
+    def chosen_inline_result
+      data = @update["chosen_inline_result"]
+      wrap_type("ChosenInlineResult", data)
+    end
+
+    def poll_update
+      data = @update["poll"]
+      wrap_type("Poll", data)
+    end
+
+    def purchased_paid_media
+      data = @update["purchased_paid_media"]
+      wrap_type("PurchasedPaidMedia", data)
+    end
+
+    def story_update
+      data = @update["story"]
+      Story.new(data, api: @api) if data
+    end
+
+    def user_status
+      data = @update["user_status"] || @update["user"]
+      User.new(data, api: @api) if data
+    end
+
+    def managed_bot_updated
+      data = @update["managed_bot_updated"] || @update["managed_bot"]
+      wrap_type("ManagedBotUpdated", data)
+    end
+
+    def error_payload
+      @update["error"]
+    end
+
+    def user
+      from
+    end
+
+    def session_data
+      return {} unless @session && user
+
+      @session.get(user.id)
+    end
+
+    def set_session(value)
+      return unless @session && user
+
+      @session.set(user.id, value)
+    end
+
+    def reply(text, keyboard = nil)
+      params = {}
+      params[:reply_markup] = keyboard if keyboard
+      @api.send_message(chat_id, text, **params)
+    end
+
+    def answer_callback(text = nil, show_alert: false)
+      id = callback_query&.id
+      return unless id
+
+      params = { callback_query_id: id, show_alert: show_alert }
+      params[:text] = text if text
+      @api.raw("answerCallbackQuery", params)
+    end
+
+    def raw(method, params = {})
+      @api.raw(method, params)
+    end
+
+    def command
+      t = text
+      return nil unless t&.start_with?("/")
+
+      token = t.split(/\s+/, 2).first
+      token.sub(%r{^/}, "").split("@", 2).first
+    end
+
+    def command_args
+      t = text
+      return [] unless t
+
+      _, rest = t.split(/\s+/, 2)
+      return [] unless rest
+
+      rest.strip.split(/\s+/)
+    end
+
+    def file_id
+      data = primary_message_payload
+      return nil unless data
+
+      if data["photo"]
+        data["photo"].last["file_id"]
+      elsif data["video"]
+        data["video"]["file_id"]
+      elsif data["audio"]
+        data["audio"]["file_id"]
+      elsif data["document"]
+        data["document"]["file_id"]
+      end
+    end
+
+    def download(file_name = "file.dat")
+      f = api.get_file(file_id)
+      api.download_file(f["file_path"], file_name)
+      file_name
+    end
+
+    private
+
+    def primary_message_payload
+      @update["message"] || @update.dig("callback_query", "message")
+    end
+
+    def user_data
+      @update.dig("message", "from") || @update.dig("callback_query", "from")
+    end
+
+    def wrap_type(type_name, data)
+      return nil unless data
+      return data unless GrubY.const_defined?(type_name)
+
+      klass = GrubY.const_get(type_name)
+      return data unless klass <= GrubY::BaseObject
+
+      klass.new(data, api: @api)
+    end
+  end
+end

data/lib/grubY/dispatcher.rb

@@ -0,0 +1,60 @@
+module GrubY
+  class Dispatcher
+    def initialize
+      @handlers = {}
+      @next_handler_id = 1
+    end
+
+    def on(event, filter = nil, group: 0, &block)
+      id = @next_handler_id
+      @next_handler_id += 1
+      (@handlers[event] ||= []) << { id: id, filter: filter, block: block, group: group.to_i }
+      @handlers[event].sort_by! { |h| h[:group] }
+      id
+    end
+
+    def off(event, handler_id = nil, &block)
+      return false unless @handlers[event]
+
+      before = @handlers[event].length
+      @handlers[event].reject! do |entry|
+        if handler_id
+          entry[:id] == handler_id
+        elsif block
+          entry[:block] == block
+        else
+          false
+        end
+      end
+      before != @handlers[event].length
+    end
+
+    def trigger(event, ctx)
+      return unless @handlers[event]
+
+      @handlers[event].each do |entry|
+        filter = entry[:filter]
+        handler = entry[:block]
+        if filter
+          pass = begin
+            if defined?(GrubY::Filters::Filter) && filter.is_a?(GrubY::Filters::Filter)
+              filter.call(nil, nil, ctx)
+            elsif filter.respond_to?(:call)
+              filter.call(ctx)
+            else
+              true
+            end
+          rescue ArgumentError
+            filter.call(nil, nil, ctx)
+          end
+          next unless pass
+        end
+        begin
+          handler.call(ctx)
+        rescue => e
+          warn "[DISPATCHER] #{event} handler failed: #{e.class}: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/grubY/enums.rb

@@ -0,0 +1,62 @@
+module GrubY
+  module Enums
+    DEFINITIONS = {
+      BlockList: %w[main stories],
+      BusinessSchedule: %w[always offline custom],
+      ButtonStyle: %w[default primary danger success],
+      ChatAction: %w[typing upload_photo record_video upload_video record_voice upload_voice upload_document choose_sticker find_location record_video_note upload_video_note],
+      ChatEventAction: %w[create edit delete pin unpin join leave invite restrict promote],
+      ChatJoinType: %w[by_link by_request by_invite by_username],
+      ChatMemberStatus: %w[creator administrator member restricted left kicked],
+      ChatMembersFilter: %w[recent administrators contacts bots banned restricted search],
+      ChatType: %w[private bot group supergroup channel direct forum],
+      ClientPlatform: %w[ruby linux windows macos android ios web],
+      FolderColor: %w[blue cyan green orange pink purple red yellow],
+      MessageEntityType: %w[mention hashtag cashtag bot_command url email phone_number bold italic underline strikethrough spoiler code pre text_link text_mention custom_emoji],
+      MessageMediaType: %w[text photo video animation audio voice video_note document sticker contact location venue poll dice game story paid_media],
+      MessageOriginType: %w[user hidden_user chat channel],
+      MessageServiceType: %w[new_chat_members left_chat_member new_chat_title new_chat_photo delete_chat_photo group_chat_created supergroup_chat_created channel_chat_created migrate_to_chat_id migrate_from_chat_id pinned_message game_score video_chat_started video_chat_ended video_chat_members_invited successful_payment],
+      MessagesFilter: %w[empty photo video document url gif voice music chat_photo phone_call round_video video_note voice_note photo_video mention unread mention_me pinned],
+      NextCodeType: %w[sms call flash_call missed_call fragment app],
+      PaidReactionPrivacy: %w[anonymous default sender],
+      ParseMode: %w[markdown markdown_v2 html],
+      PhoneCallDiscardReason: %w[missed disconnect hangup busy],
+      PhoneNumberCodeType: %w[sms call flash_call missed_call fragment app],
+      PollType: %w[regular quiz],
+      PrivacyKey: %w[last_seen phone_number profile_photo forwards calls p2p_invite link_in_bio birthday gifts voice_messages about],
+      ProfileColor: %w[blue cyan green orange pink purple red yellow],
+      ProfileTab: %w[profile gifts media links files voice],
+      ReplyColor: %w[blue cyan green orange pink purple red yellow],
+      SentCodeType: %w[sms call flash_call missed_call fragment app firebase email],
+      StoriesPrivacyRules: %w[everyone contacts close_friends selected],
+      UserStatus: %w[online offline recently last_week last_month long_time_ago],
+      UpgradedGiftOrigin: %w[upgrade gift_code transfer craft purchase],
+      GiftAttributeType: %w[model symbol backdrop rarity id original_details],
+      MediaAreaType: %w[venue location suggested_reaction link weather],
+      PrivacyRuleType: %w[allow_all allow_contacts allow_users allow_chats allow_close_friends allow_premium disallow_all disallow_contacts disallow_users disallow_chats disallow_bots],
+      GiftForResaleOrder: %w[newest oldest price_asc price_desc rarity_asc rarity_desc],
+      GiftPurchaseOfferState: %w[pending accepted rejected expired canceled],
+      GiftType: %w[regular upgraded unique collectible],
+      PaymentFormType: %w[invoice stars ton gift_upgrade],
+      StickerType: %w[regular mask custom_emoji],
+      MaskPointType: %w[forehead eyes mouth chin],
+      SuggestedPostRefundReason: %w[not_published rejected timeout canceled],
+      SuggestedPostState: %w[pending approved declined paid refunded failed]
+    }.freeze
+
+    DEFINITIONS.each do |enum_name, values|
+      enum_module = Module.new
+      values.each do |value|
+        const_name = value.upcase.gsub(/[^A-Z0-9]+/, "_")
+        enum_module.const_set(const_name, value)
+      end
+      const_set(enum_name, enum_module)
+    end
+
+    module GroupCallUpdateType
+      UPDATE_GROUP_CALL = "updateGroupCall"
+      UPDATE_GROUP_CALL_PARTICIPANTS = "updateGroupCallParticipants"
+      UPDATE_GROUP_CALL_SIGNALING_DATA = "updateGroupCallSignalingData"
+    end
+  end
+end

data/lib/grubY/exception.rb

@@ -0,0 +1,5 @@
+module GrubY
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class DependencyError < Error; end
+end

data/lib/grubY/file_stream.rb

@@ -0,0 +1,17 @@
+require "net/http"
+
+module GrubY
+  class FileStream
+    def self.download(url, dest)
+      uri = URI(url)
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        http.request_get(uri) do |res|
+          File.open(dest, "wb") do |f|
+            res.read_body { |chunk| f.write(chunk) }
+          end
+        end
+      end
+    end
+  end
+end