Class: Cinch::User

Inherits:

Target

• Object
• Target
• Cinch::User

show all

Includes:

Syncable

Defined in:

lib/cinch/user.rb

Overview

Instance Attribute Summary (collapse)

• - (String) authname readonly

  The current value of authname.

• - (String^?) away readonly

  The user’s away message, or nil if not away.

• - (Array<Channel>) channels readonly

  All channels the user is in.

• - (Hash) data readonly

  By default, you can use methods like User#user, User#host and alike – If you however fear that another thread might change data while you’re using it and if this means a critical issue to your code, you can store a clone of the result of this method and work with that instead.

• - (String) host readonly

  The current value of host.

• - (Integer) idle readonly

  How long this user has been idle, in seconds.

• - (Boolean) in_whois
• - (String) last_nick readonly
• - (Boolean) monitored

  True if the user is being monitored.

• - (Boolean) online

  unless #monitor is being used, this information cannot be ensured to be always correct.

• - (String) realname readonly

  The current value of realname.

• - (Boolean) secure readonly

  True if the user is using a secure connection, i.e.

• - (Time) signed_on_at readonly

  The current value of signed_on_at.

• - (Boolean) synced readonly
• - (Boolean) unknown readonly

  True if the instance references an user who cannot be found on the server.

• - (String) user readonly

  The current value of user.

Attributes inherited from Target

#bot, #name

Instance Method Summary (collapse)

• - (Object) attr(attribute, data = true, unsync = false)
• - (Boolean) authed?

  Checks if the user is identified.

• - dcc_send(io, filename = File.basename(io.path))

  Send data via DCC SEND to a user.

• - end_of_whois(values, not_found = false) private
• - (User) initialize(*args) constructor

  A new instance of User.

• - (String) inspect
• - (Mask) mask(s = "%n!%u@%h")

  Generates a mask for the user.

• - (Boolean) match(other) (also: #=~)

  Check if the user matches a mask.

• - (Object) method_missing(m, *args)

  Provides synced access to user attributes.

• - monitor

  Starts monitoring a user’s online state by either using MONITOR or periodically running WHOIS.

• - (Boolean) online?

  unless #monitor is being used, this information cannot be ensured to be always correct.

• - (Boolean) respond_to?(m)
• - (Boolean) secure?

  True if the user is using a secure connection, i.e.

• - (String) to_s
• - (Boolean) unknown?

  True if the instance references an user who cannot be found on the server.

• - unmonitor

  Stops monitoring a user’s online state.

• - unsync_all private
• - update_nick(new_nick) private

  Used to update the user’s nick on nickchange events.

• - whois (also: #refresh)

  Queries the IRC server for information on the user.

Methods included from Syncable

#mark_as_synced, #sync, #synced?, #unsync, #wait_until_synced

Methods inherited from Target

#<=>, #action, #concretize, #ctcp, #eql?, #msg, #notice, #safe_action, #safe_msg, #safe_notice

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

# File 'lib/cinch/user.rb', line 91

def initialize(*args)
  @data = {
    :user         => nil,
    :host         => nil,
    :realname     => nil,
    :authname     => nil,
    :idle         => 0,
    :signed_on_at => nil,
    :unknown?     => false,
    :online?      => false,
    :channels     => [],
    :secure?      => false,
    :away         => nil,
  }
  case args.size
  when 2
    @name, @bot = args
  when 4
    @data[:user], @name, @data[:host], @bot = args
  else
    raise ArgumentError
  end

  @synced_attributes  = Set.new

  @when_requesting_synced_attribute = lambda {|attr|
    unless synced?(attr)
      @data[:unknown?] = false
      unsync :unknown?

      whois
    end
  }

  @monitored = false
end

372
373
374
375
376
377
378
379
380
381
382
383

# File 'lib/cinch/user.rb', line 372

def method_missing(m, *args)
  if m.to_s =~ /^(.+)_unsynced$/
    m = $1.to_sym
    unsync = true
  end

  if @data.has_key?(m)
    attr(m, true, unsync)
  else
    super
  end
end

18
19
20

# File 'lib/cinch/user.rb', line 18

def authname
  @authname
end

18
19
20

# File 'lib/cinch/user.rb', line 18

def away
  @away
end

18
19
20

# File 'lib/cinch/user.rb', line 18

def channels
  @channels
end

on :channel do |m|
  data = m.user.data.dup
  do_something_with(data.user)
  do_something_with(data.host)
end

80
81
82

# File 'lib/cinch/user.rb', line 80

def data
  @data
end

18
19
20

# File 'lib/cinch/user.rb', line 18

def host
  @host
end

18
19
20

# File 'lib/cinch/user.rb', line 18

def idle
  @idle
end

31
32
33

# File 'lib/cinch/user.rb', line 31

def in_whois
  @in_whois
end

25
26
27

# File 'lib/cinch/user.rb', line 25

def last_nick
  @last_nick
end

85
86
87

# File 'lib/cinch/user.rb', line 85

def monitored
  @monitored
end

50
51
52

# File 'lib/cinch/user.rb', line 50

def online
  @online
end

18
19
20

# File 'lib/cinch/user.rb', line 18

def realname
  @realname
end

59
60
61

# File 'lib/cinch/user.rb', line 59

def secure
  @secure
end

18
19
20

# File 'lib/cinch/user.rb', line 18

def signed_on_at
  @signed_on_at
end

28
29
30

# File 'lib/cinch/user.rb', line 28

def synced
  @synced
end

38
39
40

# File 'lib/cinch/user.rb', line 38

def unknown
  @unknown
end

18
19
20

# File 'lib/cinch/user.rb', line 18

def user
  @user
end

138
139
140

# File 'lib/cinch/user.rb', line 138

def attr(attribute, data = true, unsync = false)
  super
end

133
134
135

# File 'lib/cinch/user.rb', line 133

def authed?
  !attr(:authname).nil?
end

310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342

# File 'lib/cinch/user.rb', line 310

def dcc_send(io, filename = File.basename(io.path))
  own_ip = bot.config.dcc.own_ip || @bot.irc.socket.addr[2]
  dcc = DCC::Outgoing::Send.new(receiver: self,
                                filename: filename,
                                io: io,
                                own_ip: own_ip
                                )

  dcc.start_server

  handler = Handler.new(@bot, :message,
                        Pattern.new(/^/,
                                    /\001DCC RESUME #{filename} #{dcc.port} (\d+)\001/,
                                    /$/)) do |m, position|
    next unless m.user == self
    dcc.seek(position.to_i)
    m.user.send "\001DCC ACCEPT #{filename} #{dcc.port} #{position}\001"

    handler.unregister
  end
  @bot.handlers.register(handler)

  @bot.loggers.info "DCC: Outgoing DCC SEND: File name: %s - Size: %dB - IP: %s - Port: %d - Status: waiting" % [filename, io.size, own_ip, dcc.port]
  dcc.send_handshake
  begin
    dcc.listen
    @bot.loggers.info "DCC: Outgoing DCC SEND: File name: %s - Size: %dB - IP: %s - Port: %d - Status: done" % [filename, io.size, own_ip, dcc.port]
  rescue Timeout::Error
    @bot.loggers.info "DCC: Outgoing DCC SEND: File name: %s - Size: %dB - IP: %s - Port: %d - Status: failed (timeout)" % [filename, io.size, own_ip, dcc.port]
  ensure
    handler.unregister
  end
end

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

# File 'lib/cinch/user.rb', line 169

def end_of_whois(values, not_found = false)
  @in_whois = false
  if not_found
    sync(:unknown?, true, true)
    self.online = false
    sync(:idle, 0, true)
    sync(:channels, [], true)

    fields = @data.keys
    fields.delete(:unknown?)
    fields.delete(:idle)
    fields.delete(:channels)
    fields.each do |field|
      sync(field, nil, true)
    end

    return
  end

  if values.nil?
    # for some reason, we did not receive user information. one
    # reason is freenode throttling WHOIS
    Thread.new do
      sleep 2
      whois
    end
    return
  end

  {
    :authname => nil,
    :idle => 0,
    :secure? => false,
    :channels => [],
  }.merge(values).each do |attr, value|
    sync(attr, value, true)
  end

  sync(:unknown?, false, true)
  self.online = true
end

225
226
227

# File 'lib/cinch/user.rb', line 225

def inspect
  "#<User nick=#{@name.inspect}>"
end

240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257

# File 'lib/cinch/user.rb', line 240

def mask(s = "%n!%u@%h")
  s = s.gsub(/%(.)/) {
    case $1
    when "n"
      @name
    when "u"
      self.user
    when "h"
      self.host
    when "r"
      self.realname
    when "a"
      self.authname
    end
  }

  Mask.new(s)
end

263
264
265

# File 'lib/cinch/user.rb', line 263

def match(other)
  Mask.from(other) =~ Mask.from(self)
end

274
275
276
277
278
279
280
281
282
283
284
285
286

# File 'lib/cinch/user.rb', line 274

def monitor
  if @bot.irc.isupport["MONITOR"] > 0
    @bot.irc.send "MONITOR + #@name"
  else
    refresh
    @monitored_timer = Timer.new(@bot, interval: 30) {
      refresh
    }
    @monitored_timer.start
  end

  @monitored = true
end

51
52
53

# File 'lib/cinch/user.rb', line 51

def online
  @online
end

386
387
388
389
390
391
392

# File 'lib/cinch/user.rb', line 386

def respond_to?(m)
  if m.to_s =~ /^(.+)_unsynced$/
    m = $1.to_sym
  end

  return @data.has_key?(m) || super
end

60
61
62

# File 'lib/cinch/user.rb', line 60

def secure
  @secure
end

220
221
222

# File 'lib/cinch/user.rb', line 220

def to_s
  @name
end

39
40
41

# File 'lib/cinch/user.rb', line 39

def unknown
  @unknown
end

293
294
295
296
297
298
299
300
301

# File 'lib/cinch/user.rb', line 293

def unmonitor
  if @bot.irc.isupport["MONITOR"] > 0
    @bot.irc.send "MONITOR - #@name"
  else
    @monitored_timer.stop if @monitored_timer
  end

  @monitored = false
end

215
216
217

# File 'lib/cinch/user.rb', line 215

def unsync_all
  super
end

366
367
368
369

# File 'lib/cinch/user.rb', line 366

def update_nick(new_nick)
  @last_nick, @name = @name, new_nick
  @bot.user_list.update_nick(self)
end

147
148
149
150
151
152
153
154
155
156
157
158
159

# File 'lib/cinch/user.rb', line 147

def whois
  return if @in_whois
  @data.keys.each do |attr|
    unsync attr
  end

  @in_whois = true
  if @bot.irc.network.whois_only_one_argument?
    @bot.irc.send "WHOIS #@name"
  else
    @bot.irc.send "WHOIS #@name #@name"
  end
end