rubirai 0.0.2

data/lib/rubirai/message.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'rubirai/messages/message'
+require 'rubirai/messages/message_chain'
+
+module Rubirai
+  class Bot
+    # Send temp message
+    #
+    # @param target_qq [Integer] target qq id
+    # @param group_id [Integer] group id
+    # @param msgs [Array<Rubirai::Message, Hash, String, Object>] messages to form a chain, can be any type
+    # @return [Integer] message id
+    def send_temp_msg(target_qq, group_id, *msgs)
+      chain = Rubirai::MessageChain.make(*msgs, bot: self)
+      resp = call :post, '/sendTempMessage', json: {
+        sessionKey: @session,
+        qq: target_qq.to_i,
+        group: group_id.to_i,
+        messageChain: chain.to_a
+      }
+      resp['messageId']
+    end
+
+    def send_msg(type, target_id, *msgs)
+      self.class.ensure_type_in type, 'group', 'friend'
+      chain = Rubirai::MessageChain.make(*msgs, bot: self)
+      resp = call :post, "/send#{type.to_s.snake_to_camel}Message", json: {
+        sessionKey: @session,
+        target: target_id.to_i,
+        messageChain: chain.to_a
+      }
+      resp['messageId']
+    end
+
+    def send_friend_msg(target_qq, *msgs)
+      send_msg :friend, target_qq, *msgs
+    end
+
+    def send_group_msg(target_group_id, *msgs)
+      send_msg :group, target_group_id, *msgs
+    end
+
+    def recall(msg_id)
+      call :post, '/recall', json: {
+        sessionKey: @session,
+        target: msg_id
+      }
+      nil
+    end
+
+    # Send image messages
+    #
+    # @param urls [Array<String>] the urls of the images
+    # @param kwargs [Hash] keys are one of [target, qq, group].
+    # @return [Array<String>] the image ids
+    def send_image_msg(urls, **kwargs)
+      urls.must_be! Array
+      urls.each do |url|
+        url.must_be! String
+      end
+      valid = %w[target qq group]
+      res = {
+        sessionKey: @session,
+        urls: urls
+      }
+      kwargs.each do |k, v|
+        res[k.to_s.downcase.to_sym] = v if valid.include? k.to_s.downcase
+      end
+      call :post, '/sendImageMessage', json: res
+    end
+
+    def send_nudge(target_id, subject_id, kind)
+      kind.to_s.downcase.must_be_one_of! %w[group friend], RubiraiError, 'kind must be one of group or friend'
+      call :post, '/sendNudge', json: {
+        sessionKey: @session,
+        target: target_id,
+        subject: subject_id,
+        kind: kind.to_s.capitalize
+      }
+      nil
+    end
+  end
+end

data/lib/rubirai/messages/message.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+require 'rubirai/utils'
+
+module Rubirai
+  # The message abstract class.
+  #
+  # @abstract
+  # @!method self.AtMessage(**kwargs)
+  #   @param kwargs [Hash{Symbol => Object}] arguments
+  #   @return [Rubirai::AtMessage]
+  # @!method self.QuoteMessage(**kwargs)
+  #   @param kwargs [Hash{Symbol => Object}] arguments
+  #   @return [Rubirai::QuoteMessage]
+  # @!method self.AtAllMessage(**kwargs)
+  #   @param kwargs [Hash{Symbol => Object}] arguments
+  #   @return [Rubirai::AtAllMessage]
+  # @!method self.FaceMessage(**kwargs)
+  #   @param kwargs [Hash{Symbol => Object}] arguments
+  #   @return [Rubirai::FaceMessage]
+  # @!method self.PlainMessage(**kwargs)
+  #   @option text [String] the plain text
+  #   @return [Rubirai::PlainMessage]
+  class Message
+    attr_reader :bot, :type
+
+    # Objects to {Rubirai::Message}
+    #
+    # @param msg [Rubirai::Message, Hash, Object] the object to transform to a message
+    # @return [Rubirai::Message] the message
+    def self.to_message(msg, bot = nil)
+      # noinspection RubyYardReturnMatch
+      case msg
+      when Message, MessageChain
+        msg
+      when Hash
+        Message.build_from(msg, bot)
+      else
+        PlainMessage.from(text: msg.to_s, bot: bot)
+      end
+    end
+
+    # Get all message types (subclasses)
+    #
+    # @return [Array<Symbol>] all message types
+    def self.all_types
+      %i[
+        Source Quote At AtAll Face Plain Image
+        FlashImage Voice Xml Json App Poke Forward
+        File MusicShare
+      ]
+    end
+
+    # Check if a type is in all message types
+    # @param type [Symbol] the type to check
+    # @return whether the type is in all message types
+    def self.check_type(type)
+      raise(RubiraiError, 'type not in all message types') unless Message.all_types.include? type
+    end
+
+    def self.get_msg_klass(type)
+      Object.const_get "Rubirai::#{type}Message"
+    end
+
+    def self.build_from(hash, bot = nil)
+      hash = hash.stringify_keys
+      raise(RubiraiError, 'not a valid message') unless hash.key? 'type'
+
+      type = hash['type'].to_sym
+      check_type type
+      klass = get_msg_klass type
+      klass.new hash, bot
+    end
+
+    def self.set_message(type, *attr_keys, &initialize_block)
+      attr_reader(*attr_keys)
+
+      metaclass.instance_eval do
+        define_method(:keys) do
+          attr_keys
+        end
+        break if attr_keys.empty?
+        define_method(:from) do |bot: nil, **kwargs|
+          res = get_msg_klass(type).new({}, bot)
+          attr_keys.each do |key|
+            res.instance_variable_set "@#{key}", kwargs[key]
+          end
+          res
+        end
+        s = +"def from_with_param(#{attr_keys.join('= nil, ')} = nil)\n"
+        s << "res = Rubirai::#{type}Message.new({})\n"
+        attr_keys.each do |key|
+          s << %[res.instance_variable_set("@#{key}", #{key})\n]
+        end
+        s << "res\nend"
+        class_eval s
+      end
+
+      class_eval do
+        define_method(:initialize) do |hash, bot = nil|
+          # noinspection RubySuperCallWithoutSuperclassInspection
+          super type, bot
+          initialize_block&.call(hash)
+          hash = hash.stringify_keys
+          attr_keys.each do |k|
+            instance_variable_set("@#{k}", hash[k.to_s.snake_to_camel(lower: true)])
+          end
+        end
+      end
+    end
+
+    def initialize(type, bot = nil)
+      Message.check_type type
+      @bot = bot
+      @type = type
+    end
+
+    def to_h
+      res = self.class.keys.to_h do |k|
+        v = instance_variable_get("@#{k}")
+        k = k.to_s.snake_to_camel(lower: true)
+        if v.is_a? MessageChain
+          [k, v.to_a]
+        elsif v&.respond_to?(:to_h)
+          [k, v.to_h]
+        else
+          [k, v]
+        end
+      end
+      res[:type] = @type.to_s
+      res.compact.stringify_keys
+    end
+
+    def self.metaclass
+      class << self
+        self
+      end
+    end
+  end
+
+  def self.Message(obj, bot = nil)
+    Message.to_message obj, bot
+  end
+
+  Message.all_types.each do |type|
+    self.class.define_method("#{type}Message".to_sym) do |**kwargs|
+      Message.get_msg_klass(type).from(**kwargs)
+    end
+  end
+
+  # The source message type
+  class SourceMessage < Message
+    # @!attribute [r] id
+    #   @return [Integer] the message (chain) id
+    # @!attribute [r] time
+    #   @return [Integer] the timestamp
+    set_message :Source, :id, :time
+  end
+
+  # The quote message type
+  class QuoteMessage < Message
+    # @!attribute [r] id
+    #   @return [Integer] the original (quoted) message (chain) id
+    # @!attribute [r] group_id
+    #   @return [Integer] the group id
+    # @!attribute [r] sender_id
+    #   @return [Integer] the original sender's id
+    # @!attribute [r] target_id
+    #   @return [Integer] the original receiver's (group or user) id
+    # @!attribute [r] origin
+    #   @return [MessageChain] the original message chain
+    set_message :Quote, :id, :group_id, :sender_id, :target_id, :origin
+
+    def initialize(hash, bot = nil)
+      super :Quote, bot
+      @id = hash['id']
+      @group_id = hash['groupId']
+      @sender_id = hash['senderId']
+      @target_id = hash['targetId']
+      @origin = MessageChain.make(*hash['origin'], sender_id: @sender_id, bot: bot)
+    end
+  end
+
+  # The At message type
+  class AtMessage < Message
+    # @!attribute [r] target
+    #   @return [Integer] the target group user's id
+    # @!attribute [r] display
+    #   @return [String] the displayed name (not used when sending)
+    # @!method from(**kwargs)
+    #   @param kwargs [Hash{Symbol => Object}] not used
+    #   @return [AtMessage] the message object
+    set_message :At, :target, :display
+  end
+
+  # The At All message type
+  class AtAllMessage < Message
+    # @!method from(**kwargs)
+    #   @param kwargs [Hash{Symbol => Object}] the fields to set
+    #   @return [AtAllMessage] the message object
+    set_message :AtAll
+  end
+
+  # The QQ Face Emoji message type
+  class FaceMessage < Message
+    # @!attribute [r] face_id
+    #   @return [Integer] the face's id
+    # @!attribute [r] name
+    #   @return [String, nil] the face's name
+    set_message :Face, :face_id, :name
+  end
+
+  # The plain text message type
+  class PlainMessage < Message
+    # @!attribute [r] text
+    #   @return [String] the text
+    set_message :Plain, :text
+  end
+
+  # The image message type.
+  # Only one out of the three fields is needed to form the message.
+  class ImageMessage < Message
+    # @!attribute [r] image_id
+    #   @return [Integer, nil] the image id from mirai
+    # @!attribute [r] url
+    #   @return [String, nil] the url of the image
+    # @!attribute [r] path
+    #   @return [String, nil] the local path of the image
+    set_message :Image, :image_id, :url, :path
+  end
+
+  # The flash image message type
+  class FlashImageMessage < Message
+    set_message :FlashImage, :image_id, :url, :path
+  end
+
+  # The voice message type
+  class VoiceMessage < Message
+    set_message :Voice, :voice_id, :url, :path
+  end
+
+  # The xml message type
+  class XmlMessage < Message
+    # @!attribute [r] xml
+    #   @return [String] the xml content
+    set_message :Xml, :xml
+  end
+
+  # The json message type
+  class JsonMessage < Message
+    # @!attribute [r] json
+    #   @return [String] the json content
+    set_message :Json, :json
+  end
+
+  # The app message type
+  class AppMessage < Message
+    # @!attribute [r] content
+    #   @return [String] the app content
+    set_message :App, :content
+  end
+
+  class PokeMessage < Message
+    set_message :Poke, :name
+  end
+
+  class ForwardMessage < Message
+    class Node
+      attr_reader :sender_id, :time, :sender_name, :message_chain
+
+      def initialize(hash, bot = nil)
+        @sender_id = hash['senderId']
+        @time = hash['time']
+        @sender_name = hash['senderName']
+        @message_chain = MessageChain.make(*hash['messageChain'], sender_id: hash['senderId'], bot: bot)
+      end
+    end
+
+    set_message :Forward, :title, :brief, :source, :summary, :node_list
+
+    def initialize(hash, bot = nil)
+      super :Forward, bot
+      @title = hash['title']
+      @brief = hash['brief']
+      @source = hash['source']
+      @summary = hash['summary']
+      @node_list = hash['nodeList'].each do |chain|
+        Node.new chain, bot
+      end
+    end
+  end
+
+  class FileMessage < Message
+    set_message :File, :id, :internal_id, :name, :size
+  end
+
+  class MusicShareMessage < Message
+    def self.all_kinds
+      %w[NeteaseCloudMusic QQMusic MiguMusic]
+    end
+
+    set_message :MusicShare, :kind, :title, :summary, :jump_url, :picture_url, :music_url, :brief do |hash|
+      raise(RubiraiError, 'non valid music type') unless all_kinds.include? hash['kind']
+    end
+  end
+end

data/lib/rubirai/messages/message_chain.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'rubirai/utils'
+require 'rubirai/messages/message'
+
+module Rubirai
+  class MessageChain
+    include Enumerable
+
+    attr_reader :bot, :sender_id, :send_time, :messages, :read_only
+
+    # Makes a message chain from a list of messages
+    #
+    # @param messages [Array<Rubirai::Message, Rubirai::MessageChain, Hash, String, Object>] a list of messages
+    # @param sender_id [Integer, nil]
+    # @param bot [Rubirai::Bot, nil]
+    # @return [Rubirai::MessageChain] the message chain
+    def self.make(*messages, sender_id: nil, bot: nil)
+      chain = new(bot, sender_id: sender_id)
+      result = []
+      messages.map { |msg| Message.to_message(msg, bot) }.each do |msg|
+        if !result.empty? && result[-1].is_a?(PlainMessage) && msg.is_a?(PlainMessage)
+          result[-1] = PlainMessage.from(text: result[-1].text + msg.text, bot: bot)
+        else
+          result.append msg
+        end
+      end
+      chain.extend(*result)
+      chain
+    end
+
+    # Append messages to this message chain
+    #
+    # @param messages [Array<Rubirai::Message, Hash>] a list of messages
+    # @return [Rubirai::MessageChain] self
+    def extend(*messages)
+      messages.each do |msg|
+        internal_append msg
+      end
+      self
+    end
+
+    alias << extend
+    alias append extend
+
+    def concat(msg_chain)
+      msg_chain.to_a.each do |msg|
+        internal_append msg
+      end
+      self
+    end
+
+    def [](idx)
+      @messages[idx]
+    end
+
+    def each(&block)
+      @messages.each(&block)
+    end
+
+    def length
+      @messages.length
+    end
+
+    def size
+      @messages.size
+    end
+
+    def empty?
+      @messages.empty?
+    end
+
+    # @param bot [Rubirai::Bot, nil]
+    # @param source [Array, nil]
+    # @param sender_id [Integer, nil]
+    def initialize(bot = nil, source = nil, sender_id: nil)
+      @bot = bot
+      @sender_id = sender_id
+      @messages = []
+      return unless source
+      raise(MiraiError, 'source is not array') unless source.is_a? Array
+      raise(MiraiError, 'length is zero') if source.empty?
+
+      if source[0]['type'] == 'Source'
+        @sender_id = source[0]['id']
+        @send_time = source[0]['time']
+        extend(*source.drop(1))
+      else
+        extend(*source)
+      end
+    end
+
+    def to_a
+      @messages.map(&:to_h)
+    end
+
+    private
+
+    def internal_append(msg)
+      msg.must_be! [Message, MessageChain, Hash], RubiraiError, 'msg must be Message, MessageChain, or Hash'
+
+      case msg
+      when Message
+        @messages.append msg
+      when MessageChain
+        @messages.append(*msg.messages)
+      else
+        @messages.append Message.build_from(msg, @bot)
+      end
+
+      self
+    end
+  end
+
+  # Makes a message chain. See {MessageChain#make}.
+  def self.MessageChain(*messages, sender_id: nil, bot: nil)
+    MessageChain.make(*messages, sender_id: sender_id, bot: bot)
+  end
+end