summaryrefslogtreecommitdiff
path: root/lib/rbot/message.rb
blob: eabb569a5beec41c7dcd76fea16aafd50e2c25d9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
module Irc
  BotConfig.register BotConfigArrayValue.new('core.address_prefix',
    :default => [], :wizard => true,
    :desc => "what non nick-matching prefixes should the bot respond to as if addressed (e.g !, so that '!foo' is treated like 'rbot: foo')"
  )

  # base user message class, all user messages derive from this
  # (a user message is defined as having a source hostmask, a target
  # nick/channel and a message part)
  class BasicUserMessage
    
    # associated bot
    attr_reader :bot
    
    # when the message was received
    attr_reader :time

    # hostmask of message source
    attr_reader :source
    
    # nick of message source
    attr_reader :sourcenick
    
    # url part of message source
    attr_reader :sourceaddress
    
    # nick/channel message was sent to
    attr_reader :target
    
    # contents of the message
    attr_accessor :message

    # has the message been replied to/handled by a plugin?
    attr_accessor :replied

    # instantiate a new Message
    # bot::      associated bot class
    # source::   hostmask of the message source
    # target::   nick/channel message is destined for
    # message::  message part
    def initialize(bot, source, target, message)
      @time = Time.now
      @bot = bot
      @source = source
      @address = false
      @target = target
      @message = BasicUserMessage.stripcolour message
      @replied = false

      # split source into consituent parts
      if source =~ /^((\S+)!(\S+))$/
        @sourcenick = $2
        @sourceaddress = $3
      end
      
      if target && target.downcase == @bot.nick.downcase
        @address = true
      end
      
    end
    
    # returns true if the message was addressed to the bot.
    # This includes any private message to the bot, or any public message
    # which looks like it's addressed to the bot, e.g. "bot: foo", "bot, foo",
    # a kick message when bot was kicked etc.
    def address?
      return @address
    end

    # has this message been replied to by a plugin?
    def replied?
      return @replied
    end

    # strip mIRC colour escapes from a string
    def BasicUserMessage.stripcolour(string)
      return "" unless string
      ret = string.gsub(/\cC\d\d?(?:,\d\d?)?/, "")
      #ret.tr!("\x00-\x1f", "")
      ret
    end

  end

  # class for handling IRC user messages. Includes some utilities for handling
  # the message, for example in plugins.
  # The +message+ member will have any bot addressing "^bot: " removed
  # (address? will return true in this case)
  class UserMessage < BasicUserMessage
    
    # for plugin messages, the name of the plugin invoked by the message
    attr_reader :plugin
    
    # for plugin messages, the rest of the message, with the plugin name
    # removed
    attr_reader :params

    # convenience member. Who to reply to (i.e. would be sourcenick for a
    # privately addressed message, or target (the channel) for a publicly
    # addressed message
    attr_reader :replyto

    # channel the message was in, nil for privately addressed messages
    attr_reader :channel
    
    # for PRIVMSGs, true if the message was a CTCP ACTION (CTCP stuff
    # will be stripped from the message)
    attr_reader :action
    
    # instantiate a new UserMessage
    # bot::      associated bot class
    # source::   hostmask of the message source
    # target::   nick/channel message is destined for
    # message::  message part
    def initialize(bot, source, target, message)
      super(bot, source, target, message)
      @target = target
      @private = false
      @plugin = nil
      @action = false
      
      if target.downcase == @bot.nick.downcase
        @private = true
        @address = true
        @channel = nil
        @replyto = @sourcenick
      else
        @replyto = @target
        @channel = @target
      end

      # check for option extra addressing prefixes, e.g "|search foo", or
      # "!version" - first match wins
      bot.config['core.address_prefix'].each {|mprefix|
        if @message.gsub!(/^#{Regexp.escape(mprefix)}\s*/, "")
          @address = true
          break
        end
      }
      
      # even if they used above prefixes, we allow for silly people who
      # combine all possible types, e.g. "|rbot: hello", or 
      # "/msg rbot rbot: hello", etc
      if @message.gsub!(/^\s*#{Regexp.escape(bot.nick)}\s*([:;,>]|\s)\s*/, "")
        @address = true
      end
      
      if(@message =~ /^\001ACTION\s(.+)\001/)
        @message = $1
        @action = true
      end
      
      # free splitting for plugins
      @params = @message.dup
      if @params.gsub!(/^\s*(\S+)[\s$]*/, "")
        @plugin = $1.downcase
        @params = nil unless @params.length > 0
      end
    end

    # returns true for private messages, e.g. "/msg bot hello"
    def private?
      return @private
    end

    # returns true if the message was in a channel
    def public?
      return !@private
    end

    def action?
      return @action
    end

    # convenience method to reply to a message, useful in plugins. It's the
    # same as doing:
    # <tt>@bot.say m.replyto, string</tt>
    # So if the message is private, it will reply to the user. If it was
    # in a channel, it will reply in the channel.
    def reply(string)
      @bot.say @replyto, string
      @replied = true
    end

    # convenience method to reply "okay" in the current language to the
    # message
    def okay
      @bot.say @replyto, @bot.lang.get("okay")
    end

  end

  # class to manage IRC PRIVMSGs
  class PrivMessage < UserMessage
  end
  
  # class to manage IRC NOTICEs
  class NoticeMessage < UserMessage
  end

  # class to manage IRC KICKs
  # +address?+ can be used as a shortcut to see if the bot was kicked,
  # basically, +target+ was kicked from +channel+ by +source+ with +message+
  class KickMessage < BasicUserMessage
    # channel user was kicked from
    attr_reader :channel
    
    def initialize(bot, source, target, channel, message="")
      super(bot, source, target, message)
      @channel = channel
    end
  end

  # class to pass IRC Nick changes in. @message contains the old nickame,
  # @sourcenick contains the new one.
  class NickMessage < BasicUserMessage
    def initialize(bot, source, oldnick, newnick)
      super(bot, source, oldnick, newnick)
    end
  end

  class QuitMessage < BasicUserMessage
    def initialize(bot, source, target, message="")
      super(bot, source, target, message)
    end
  end

  class TopicMessage < BasicUserMessage
    # channel topic
    attr_reader :topic
    # topic set at (unixtime)
    attr_reader :timestamp
    # topic set on channel
    attr_reader :channel

    def initialize(bot, source, channel, timestamp, topic="")
      super(bot, source, channel, topic)
      @topic = topic
      @timestamp = timestamp
      @channel = channel
    end
  end

  # class to manage channel joins
  class JoinMessage < BasicUserMessage
    # channel joined
    attr_reader :channel
    def initialize(bot, source, channel, message="")
      super(bot, source, channel, message)
      @channel = channel
      # in this case sourcenick is the nick that could be the bot
      @address = (sourcenick.downcase == @bot.nick.downcase)
    end
  end
  
  # class to manage channel parts
  # same as a join, but can have a message too
  class PartMessage < JoinMessage
  end
end