gruubY 0.2.0

data/lib/grubY/filters.rb

@@ -0,0 +1,292 @@
+require "set"
+
+module GrubY
+  module Filters
+    class Filter
+      attr_reader :name
+
+      def initialize(name = "Filter", &block)
+        @name = name
+        @block = block || proc { true }
+      end
+
+      def call(*args)
+        @block.call(*args)
+      end
+
+      def &(other)
+        Filter.new("(#{name}&#{other.name})") { |*args| call(*args) && other.call(*args) }
+      end
+
+      def |(other)
+        Filter.new("(#{name}|#{other.name})") { |*args| call(*args) || other.call(*args) }
+      end
+
+      def ~@
+        Filter.new("~#{name}") { |*args| !call(*args) }
+      end
+    end
+
+    class EntityFilter < Filter
+      attr_reader :values
+
+      def initialize(name, values = nil, &matcher)
+        @values = normalize(values)
+        @matcher = matcher
+        super(name) do |_filter, _client, update|
+          @matcher.call(update, @values)
+        end
+      end
+
+      def add(value)
+        @values.merge(normalize(value))
+        self
+      end
+
+      def delete(value)
+        normalize(value).each { |v| @values.delete(v) }
+        self
+      end
+
+      def clear
+        @values.clear
+        self
+      end
+
+      private
+
+      def normalize(v)
+        Array(v).flatten.compact.map(&:to_s).to_set
+      end
+    end
+
+    module_function
+
+    def create(func:, name: "CustomFilter", **kwargs)
+      Filter.new(name) do |filter, client, update|
+        func.call(filter, client, update, **kwargs)
+      end
+    end
+
+    def all
+      Filter.new("all") { true }
+    end
+
+    def me
+      Filter.new("me") do |_f, _c, u|
+        msg = message_from(u)
+        msg&.from&.is_bot == false && (msg&.from&.is_self == true || %w[me self].include?(msg&.from&.username.to_s.downcase))
+      end
+    end
+
+    def bot
+      Filter.new("bot") { |_f, _c, u| message_from(u)&.from&.is_bot == true }
+    end
+
+    def sender_chat
+      Filter.new("sender_chat") { |_f, _c, u| !message_from(u)&.sender_chat.nil? }
+    end
+
+    def incoming
+      Filter.new("incoming") { |_f, _c, u| message_from(u)&.from&.is_bot != true }
+    end
+
+    def outgoing
+      Filter.new("outgoing") do |_f, _c, u|
+        msg = message_from(u)
+        msg && msg.from && (msg.from.is_self == true || msg.from.id == msg.chat&.id)
+      end
+    end
+
+    def text = has_key_filter("text")
+    def reply = Filter.new("reply") { |_f, _c, u| !!(message_from(u)&.reply_to_message || message_from(u)&.reply_to_story) }
+    def forwarded = Filter.new("forwarded") { |_f, _c, u| !!message_from(u)&.forward_origin }
+    def caption = has_key_filter("caption")
+    def self_destruction = has_key_filter("self_destruction")
+    def audio = has_key_filter("audio")
+    def document = has_key_filter("document")
+    def photo = has_key_filter("photo")
+    def sticker = has_key_filter("sticker")
+    def animation = has_key_filter("animation")
+    def game = has_key_filter("game")
+    def giveaway = has_key_filter("giveaway")
+    def giveaway_winners = has_key_filter("giveaway_winners")
+    def gift_code = has_key_filter("gift_code")
+    def gift = has_key_filter("gift")
+    def users_shared = has_key_filter("users_shared")
+    def chat_shared = has_key_filter("chat_shared")
+    def video = has_key_filter("video")
+    def media_group = has_key_filter("media_group_id")
+    def voice = has_key_filter("voice")
+    def video_note = has_key_filter("video_note")
+    def contact = has_key_filter("contact")
+    def location = has_key_filter("location")
+    def live_location = Filter.new("live_location") { |_f, _c, u| !!message_from(u)&.location&.dig("live_period") }
+    def venue = has_key_filter("venue")
+    def web_page = Filter.new("web_page") { |_f, _c, u| !!message_from(u)&.link_preview_options }
+    def poll = has_key_filter("poll")
+    def dice = has_key_filter("dice")
+    def quote = has_key_filter("quote")
+    def media_spoiler = has_key_filter("has_media_spoiler")
+    def story = has_key_filter("story")
+    def new_chat_members = has_key_filter("new_chat_members")
+    def left_chat_member = has_key_filter("left_chat_member")
+    def new_chat_title = has_key_filter("new_chat_title")
+    def new_chat_photo = has_key_filter("new_chat_photo")
+    def delete_chat_photo = has_key_filter("delete_chat_photo")
+    def group_chat_created = has_key_filter("group_chat_created")
+    def supergroup_chat_created = has_key_filter("supergroup_chat_created")
+    def channel_chat_created = has_key_filter("channel_chat_created")
+    def migrate_to_chat_id = has_key_filter("migrate_to_chat_id")
+    def migrate_from_chat_id = has_key_filter("migrate_from_chat_id")
+    def pinned_message = has_key_filter("pinned_message")
+    def game_high_score = has_key_filter("game_high_score")
+    def reply_keyboard = has_key_filter("reply_markup")
+    def inline_keyboard = has_key_filter("reply_markup")
+    def mentioned = Filter.new("mentioned") { |_f, _c, u| message_from(u)&.entities&.any? { |e| e["type"] == "mention" } }
+    def via_bot = has_key_filter("via_bot")
+    def admin = Filter.new("admin") { |_f, _c, u| %w[administrator creator].include?(message_from(u)&.chat_member_status.to_s) }
+    def video_chat_started = has_key_filter("video_chat_started")
+    def video_chat_ended = has_key_filter("video_chat_ended")
+    def business = has_key_filter("business_connection_id")
+    def video_chat_members_invited = has_key_filter("video_chat_members_invited")
+    def successful_payment = has_key_filter("successful_payment")
+    def scheduled = has_key_filter("is_scheduled")
+    def from_scheduled = has_key_filter("from_scheduled")
+    def paid_message = has_key_filter("is_paid_post")
+    def linked_channel = has_key_filter("is_automatic_forward")
+    def gift_offer = has_key_filter("gift_offer")
+    def gift_offer_accepted = has_key_filter("gift_offer_accepted")
+    def gift_offer_rejected = has_key_filter("gift_offer_rejected")
+
+    def service
+      Filter.new("service") do |_f, _c, u|
+        msg = message_from(u)
+        next false unless msg
+
+        %w[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 video_chat_started video_chat_ended video_chat_members_invited successful_payment].any? do |k|
+          present_key?(msg, k)
+        end
+      end
+    end
+
+    def media
+      Filter.new("media") do |_f, _c, u|
+        msg = message_from(u)
+        next false unless msg
+
+        %w[audio document photo sticker video animation voice video_note contact location venue poll].any? { |k| present_key?(msg, k) }
+      end
+    end
+
+    def private
+      Filter.new("private") { |_f, _c, u| message_from(u)&.chat&.type == "private" }
+    end
+
+    def group
+      Filter.new("group") { |_f, _c, u| %w[group supergroup].include?(message_from(u)&.chat&.type) }
+    end
+
+    def channel
+      Filter.new("channel") { |_f, _c, u| message_from(u)&.chat&.type == "channel" }
+    end
+
+    def direct
+      Filter.new("direct") { |_f, _c, u| message_from(u)&.chat&.is_direct_messages == true }
+    end
+
+    def forum
+      Filter.new("forum") { |_f, _c, u| message_from(u)&.chat&.is_forum == true }
+    end
+
+    def command(commands, prefixes: "/", case_sensitive: false)
+      list = Array(commands).map(&:to_s)
+      prefix_list = prefixes.nil? ? [""] : Array(prefixes).map(&:to_s)
+      Filter.new("command") do |_f, _c, u|
+        msg = message_from(u)
+        text = msg&.text.to_s
+        next false if text.empty?
+        next false unless prefix_list.any? { |p| p.empty? || text.start_with?(p) }
+
+        cmd = text.split(/\s+/, 2).first.to_s
+        cmd = cmd.sub(/\A[#{Regexp.escape(prefix_list.join)}]/, "") unless prefix_list.include?("")
+        cmd = cmd.split("@", 2).first
+        cmd = cmd.downcase unless case_sensitive
+        expected = case_sensitive ? list : list.map(&:downcase)
+        expected.include?(cmd)
+      end
+    end
+
+    def regex(pattern, flags: 0)
+      reg = pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern.to_s, flags)
+      Filter.new("regex") do |_f, _c, u|
+        target = if u.respond_to?(:data) && !u.data.to_s.empty?
+                   u.data.to_s
+                 elsif u.respond_to?(:query)
+                   u.query.to_s
+                 else
+                   msg = message_from(u)
+                   msg&.text.to_s.empty? ? msg&.caption.to_s : msg&.text.to_s
+                 end
+        !!(target =~ reg)
+      end
+    end
+
+    def user(users = nil)
+      require "set"
+      EntityFilter.new("user", users) do |u, values|
+        msg = message_from(u)
+        uid = msg&.from&.id || u&.from&.id
+        uname = msg&.from&.username || u&.from&.username
+        values.empty? || values.include?(uid.to_s) || values.include?(uname.to_s) || values.include?("me")
+      end
+    end
+
+    def chat(chats = nil)
+      require "set"
+      EntityFilter.new("chat", chats) do |u, values|
+        msg = message_from(u)
+        cid = msg&.chat&.id || u&.chat&.id
+        uname = msg&.chat&.username || u&.chat&.username
+        values.empty? || values.include?(cid.to_s) || values.include?(uname.to_s) || values.include?("me")
+      end
+    end
+
+    def topic(topics = nil)
+      require "set"
+      EntityFilter.new("topic", topics) do |u, values|
+        msg = message_from(u)
+        tid = msg&.message_thread_id || msg&.direct_messages_topic&.dig("topic_id")
+        values.empty? || values.include?(tid.to_s)
+      end
+    end
+
+    private_class_method
+
+    def has_key_filter(key)
+      Filter.new(key) { |_f, _c, u| present_key?(message_from(u), key) }
+    end
+
+    def present_key?(obj, key)
+      return false unless obj
+      value = if obj.respond_to?(:[])
+                obj[key]
+              elsif obj.respond_to?(key)
+                obj.public_send(key)
+              end
+      !(value.nil? || (value.respond_to?(:empty?) && value.empty?))
+    end
+
+    def message_from(update)
+      return update if update.is_a?(GrubY::Message)
+      return update.message if update.respond_to?(:message)
+      return update.edited_message if update.respond_to?(:edited_message)
+      return update.business_message if update.respond_to?(:business_message)
+      return update.edited_business_message if update.respond_to?(:edited_business_message)
+
+      nil
+    end
+  end
+end

data/lib/grubY/group_manager.rb

@@ -0,0 +1,213 @@
+module GrubY
+  class GroupManager
+    DEFAULT_WARN_LIMIT = 3
+
+    def initialize(api, session: nil, warn_limit: DEFAULT_WARN_LIMIT)
+      @api = api
+      @session = session
+      @warn_limit = warn_limit
+    end
+
+    def ban(chat_id, user_id, **opts)
+      @api.ban_chat_member(chat_id: chat_id, user_id: user_id, **opts)
+    end
+
+    def unban(chat_id, user_id, **opts)
+      @api.unban_chat_member(chat_id: chat_id, user_id: user_id, **opts)
+    end
+
+    def kick(chat_id, user_id, **opts)
+      ban(chat_id, user_id, **opts)
+      unban(chat_id, user_id)
+    end
+
+    def restrict(chat_id, user_id, permissions:, **opts)
+      @api.restrict_chat_member(
+        chat_id: chat_id,
+        user_id: user_id,
+        permissions: permissions,
+        **opts
+      )
+    end
+
+    def mute(chat_id, user_id, until_date: nil)
+      restrict(
+        chat_id,
+        user_id,
+        permissions: { can_send_messages: false },
+        until_date: until_date
+      )
+    end
+
+    def unmute(chat_id, user_id)
+      permissions = {
+        can_send_messages: true,
+        can_send_audios: true,
+        can_send_documents: true,
+        can_send_photos: true,
+        can_send_videos: true,
+        can_send_video_notes: true,
+        can_send_voice_notes: true,
+        can_send_polls: true,
+        can_send_other_messages: true,
+        can_add_web_page_previews: true
+      }
+      restrict(chat_id, user_id, permissions: permissions)
+    end
+
+    def promote(chat_id, user_id, **opts)
+      @api.promote_chat_member(chat_id: chat_id, user_id: user_id, **opts)
+    end
+
+    def demote(chat_id, user_id)
+      promote(
+        chat_id,
+        user_id,
+        can_manage_chat: false,
+        can_delete_messages: false,
+        can_manage_video_chats: false,
+        can_restrict_members: false,
+        can_promote_members: false,
+        can_change_info: false,
+        can_invite_users: false,
+        can_post_stories: false,
+        can_edit_stories: false,
+        can_delete_stories: false,
+        can_post_messages: false,
+        can_edit_messages: false,
+        can_pin_messages: false,
+        can_manage_topics: false
+      )
+    end
+
+    def set_member_tag(chat_id, user_id, tag = nil)
+      @api.set_chat_member_tag(chat_id: chat_id, user_id: user_id, tag: tag)
+    end
+
+    def set_admin_title(chat_id, user_id, title)
+      @api.set_chat_administrator_custom_title(
+        chat_id: chat_id,
+        user_id: user_id,
+        custom_title: title
+      )
+    end
+
+    def set_administrator_title(chat_id, user_id, title)
+      set_admin_title(chat_id, user_id, title)
+    end
+
+    def set_chat_title(chat_id, title)
+      @api.set_chat_title(chat_id: chat_id, title: title)
+    end
+
+    def set_chat_description(chat_id, description)
+      @api.set_chat_description(chat_id: chat_id, description: description)
+    end
+
+    def set_chat_photo(chat_id, photo)
+      @api.set_chat_photo(chat_id: chat_id, photo: photo)
+    end
+
+    def delete_chat_photo(chat_id)
+      @api.delete_chat_photo(chat_id: chat_id)
+    end
+
+    def leave_chat(chat_id)
+      @api.leave_chat(chat_id: chat_id)
+    end
+
+    def set_permissions(chat_id, permissions, **opts)
+      @api.set_chat_permissions(chat_id: chat_id, permissions: permissions, **opts)
+    end
+
+    def lock(chat_id)
+      set_permissions(chat_id, { can_send_messages: false })
+    end
+
+    def unlock(chat_id)
+      set_permissions(chat_id, { can_send_messages: true })
+    end
+
+    def set_slow_mode(chat_id, seconds)
+      @api.set_slow_mode(chat_id: chat_id, seconds: seconds)
+    end
+
+    def pin(chat_id, message_id, **opts)
+      @api.pin_chat_message(chat_id: chat_id, message_id: message_id, **opts)
+    end
+
+    def unpin(chat_id, message_id = nil, **opts)
+      params = { chat_id: chat_id }.merge(opts)
+      params[:message_id] = message_id if message_id
+      @api.unpin_chat_message(**params)
+    end
+
+    def unpin_all(chat_id)
+      @api.unpin_all_chat_messages(chat_id: chat_id)
+    end
+
+    def approve_join_request(chat_id, user_id)
+      @api.approve_chat_join_request(chat_id: chat_id, user_id: user_id)
+    end
+
+    def decline_join_request(chat_id, user_id)
+      @api.decline_chat_join_request(chat_id: chat_id, user_id: user_id)
+    end
+
+    def get_chat(chat_id)
+      @api.get_chat(chat_id: chat_id)
+    end
+
+    def get_member(chat_id, user_id)
+      @api.get_chat_member(chat_id: chat_id, user_id: user_id)
+    end
+
+    def warn(chat_id, user_id, reason: nil)
+      key = warn_key(chat_id, user_id)
+      current = load_warns(key)
+      current += 1
+      store_warns(key, current)
+
+      {
+        user_id: user_id,
+        warns: current,
+        limit: @warn_limit,
+        reason: reason,
+        action: (current >= @warn_limit ? :kick : :none)
+      }
+    end
+
+    def reset_warns(chat_id, user_id)
+      key = warn_key(chat_id, user_id)
+      store_warns(key, 0)
+    end
+
+    def enforce_warns(chat_id, user_id, reason: nil)
+      result = warn(chat_id, user_id, reason: reason)
+      return result unless result[:action] == :kick
+
+      kick(chat_id, user_id)
+      reset_warns(chat_id, user_id)
+      result
+    end
+
+    private
+
+    def warn_key(chat_id, user_id)
+      "warns:#{chat_id}:#{user_id}"
+    end
+
+    def load_warns(key)
+      return 0 unless @session
+
+      value = @session.get(key)
+      value.is_a?(Hash) ? value["count"].to_i : value.to_i
+    end
+
+    def store_warns(key, count)
+      return unless @session
+
+      @session.set(key, { "count" => count })
+    end
+  end
+end

data/lib/grubY/handlers.rb

@@ -0,0 +1,170 @@
+module GrubY
+  module Handlers
+    class BaseHandler
+      attr_reader :callback, :filters, :group, :exceptions
+
+      def initialize(callback = nil, filters: nil, group: 0, exceptions: nil, &block)
+        @callback = callback || block
+        @filters = filters
+        @group = group.to_i
+        @exceptions = exceptions
+      end
+
+      def event
+        raise NotImplementedError
+      end
+
+      def extract(ctx)
+        ctx
+      end
+
+      def client_only?
+        false
+      end
+    end
+
+    class MessageHandler < BaseHandler
+      def event = :message
+      def extract(ctx) = ctx.message
+    end
+
+    class EditedMessageHandler < BaseHandler
+      def event = :edited_message
+      def extract(ctx) = ctx.edited_message
+    end
+
+    class DeletedMessagesHandler < BaseHandler
+      def event = :deleted_messages
+      def extract(ctx) = ctx.deleted_messages
+    end
+
+    class BusinessMessageHandler < BaseHandler
+      def event = :business_message
+      def extract(ctx) = ctx.business_message
+    end
+
+    class EditedBusinessMessageHandler < BaseHandler
+      def event = :edited_business_message
+      def extract(ctx) = ctx.edited_business_message
+    end
+
+    class DeletedBusinessMessagesHandler < BaseHandler
+      def event = :deleted_business_messages
+      def extract(ctx) = ctx.deleted_business_messages
+    end
+
+    class BusinessConnectionHandler < BaseHandler
+      def event = :business_connection
+      def extract(ctx) = ctx.business_connection
+    end
+
+    class CallbackQueryHandler < BaseHandler
+      def event = :callback_query
+      def extract(ctx) = ctx.callback_query
+    end
+
+    class ChatBoostHandler < BaseHandler
+      def event = :chat_boost
+      def extract(ctx) = ctx.chat_boost
+    end
+
+    class ChatJoinRequestHandler < BaseHandler
+      def event = :chat_join_request
+      def extract(ctx) = ctx.chat_join_request
+    end
+
+    class ChatMemberUpdatedHandler < BaseHandler
+      def event = :chat_member_updated
+      def extract(ctx) = ctx.chat_member_updated
+    end
+
+    class ChosenInlineResultHandler < BaseHandler
+      def event = :chosen_inline_result
+      def extract(ctx) = ctx.chosen_inline_result
+    end
+
+    class InlineQueryHandler < BaseHandler
+      def event = :inline_query
+      def extract(ctx) = ctx.inline_query
+    end
+
+    class MessageReactionCountHandler < BaseHandler
+      def event = :message_reaction_count
+      def extract(ctx) = ctx.message_reaction_count
+    end
+
+    class MessageReactionHandler < BaseHandler
+      def event = :message_reaction
+      def extract(ctx) = ctx.message_reaction
+    end
+
+    class PollHandler < BaseHandler
+      def event = :poll
+      def extract(ctx) = ctx.poll_update
+    end
+
+    class PreCheckoutQueryHandler < BaseHandler
+      def event = :pre_checkout_query
+      def extract(ctx) = ctx.pre_checkout_query
+    end
+
+    class PurchasedPaidMediaHandler < BaseHandler
+      def event = :purchased_paid_media
+      def extract(ctx) = ctx.purchased_paid_media
+    end
+
+    class ShippingQueryHandler < BaseHandler
+      def event = :shipping_query
+      def extract(ctx) = ctx.shipping_query
+    end
+
+    class StoryHandler < BaseHandler
+      def event = :story
+      def extract(ctx) = ctx.story_update
+    end
+
+    class UserStatusHandler < BaseHandler
+      def event = :user_status
+      def extract(ctx) = ctx.user_status
+    end
+
+    class StartHandler < BaseHandler
+      def event = :start
+      def extract(_ctx) = nil
+      def client_only? = true
+    end
+
+    class StopHandler < BaseHandler
+      def event = :stop
+      def extract(_ctx) = nil
+      def client_only? = true
+    end
+
+    class ConnectHandler < BaseHandler
+      def event = :connect
+      def extract(_ctx) = nil
+      def client_only? = true
+    end
+
+    class DisconnectHandler < BaseHandler
+      def event = :disconnect
+      def extract(_ctx) = nil
+      def client_only? = true
+    end
+
+    class ErrorHandler < BaseHandler
+      def event = :error
+      def extract(ctx) = ctx.error_payload
+    end
+
+    class ManagedBotUpdatedHandler < BaseHandler
+      def event = :managed_bot
+      def extract(ctx) = ctx.managed_bot_updated
+    end
+
+    class RawUpdateHandler < BaseHandler
+      def event = :raw_update
+      def extract(ctx) = ctx.update
+    end
+  end
+end