Class: Discorb::Client

Inherits:
Object
  • Object
show all
Includes:
ApplicationCommand::Handler, Gateway::Handler
Defined in:
lib/discorb/client.rb

Overview

Class for connecting to the Discord server.

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from ApplicationCommand::Handler

#message_command, #setup_commands, #slash, #slash_group, #user_command

Constructor Details

#initialize(allowed_mentions: nil, intents: nil, message_caches: 1000, logger: nil, wait_until_ready: true, fetch_member: false, title: nil) ⇒ Client

Initializes a new client.



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
 
# File 'lib/discorb/client.rb', line 86

def initialize(
  allowed_mentions: nil, intents: nil, message_caches: 1000,
  logger: nil,
  wait_until_ready: true, fetch_member: false,
  title: nil
)
  @allowed_mentions = allowed_mentions || AllowedMentions.new(everyone: true, roles: true, users: true)
  @intents = (intents or Intents.default)
  @events = {}
  @api_version = nil
  @logger = logger || Logger.new($stdout, progname: "discorb")
  @user = nil
  @users = Discorb::Dictionary.new
  @channels = Discorb::Dictionary.new
  @guilds = Discorb::Dictionary.new(sort: ->(k) { k[0].to_i })
  @emojis = Discorb::Dictionary.new
  @messages = Discorb::Dictionary.new(limit: message_caches)
  @application = nil
  @last_s = nil
  @identify_presence = nil
  @wait_until_ready = wait_until_ready
  @ready = false
  @tasks = []
  @conditions = {}
  @commands = []
  @bottom_commands = []
  @status = :initialized
  @fetch_member = fetch_member
  @title = title
  @extensions = {}
  @mutex = {}
  @shards = {}
  set_default_events
end

Instance Attribute Details

#allowed_mentions ⇒ Discorb::AllowedMentions (readonly) 



30
31
32
 
# File 'lib/discorb/client.rb', line 30

def allowed_mentions
  @allowed_mentions
end

#api_version ⇒ Integer? (readonly) 



26
27
28
 
# File 'lib/discorb/client.rb', line 26

def api_version
  @api_version
end

#application ⇒ Discorb::Application? (readonly) 



19
20
21
 
# File 'lib/discorb/client.rb', line 19

def application
  @application
end

#channels ⇒ Discorb::Dictionary{Discorb::Snowflake => Discorb::Channel} (readonly) 



38
39
40
 
# File 'lib/discorb/client.rb', line 38

def channels
  @channels
end

#commands ⇒ Array<Discorb::ApplicationCommand::Command> (readonly) 



44
45
46
 
# File 'lib/discorb/client.rb', line 44

def commands
  @commands
end

#emojis ⇒ Discorb::Dictionary{Discorb::Snowflake => Discorb::Emoji} (readonly) 



40
41
42
 
# File 'lib/discorb/client.rb', line 40

def emojis
  @emojis
end

#extensions ⇒ Hash{String => Discorb::Extension} (readonly) 



52
53
54
 
# File 'lib/discorb/client.rb', line 52

def extensions
  @extensions
end

#guilds ⇒ Discorb::Dictionary{Discorb::Snowflake => Discorb::Guild} (readonly) 



34
35
36
 
# File 'lib/discorb/client.rb', line 34

def guilds
  @guilds
end

#heartbeat_interval ⇒ Integer (readonly) 



23
24
25
 
# File 'lib/discorb/client.rb', line 23

def heartbeat_interval
  @heartbeat_interval
end

#http ⇒ Discorb::HTTP (readonly) 



21
22
23
 
# File 'lib/discorb/client.rb', line 21

def http
  @http
end

#intents ⇒ Discorb::Intents 



16
17
18
 
# File 'lib/discorb/client.rb', line 16

def intents
  @intents
end

#logger ⇒ Logger (readonly) 




# File 'lib/discorb/client.rb', line 62

#messages ⇒ Discorb::Dictionary{Discorb::Snowflake => Discorb::Message} (readonly) 



42
43
44
 
# File 'lib/discorb/client.rb', line 42

def messages
  @messages
end

#ping ⇒ Float? (readonly) 



48
49
50
 
# File 'lib/discorb/client.rb', line 48

def ping
  @ping
end

#session_id ⇒ String? 




# File 'lib/discorb/client.rb', line 62

#shard ⇒ Discorb::Shard? (readonly) 




# File 'lib/discorb/client.rb', line 62

#shard_id ⇒ Discorb::Shard? (readonly) 




# File 'lib/discorb/client.rb', line 62

#shards ⇒ Hash{Integer => Discorb::Shard} (readonly) 



54
55
56
 
# File 'lib/discorb/client.rb', line 54

def shards
  @shards
end

#status ⇒ :initialized, ... (readonly) 



50
51
52
 
# File 'lib/discorb/client.rb', line 50

def status
  @status
end

#token ⇒ String (readonly) 



28
29
30
 
# File 'lib/discorb/client.rb', line 28

def token
  @token
end

#user ⇒ Discorb::ClientUser (readonly) 



32
33
34
 
# File 'lib/discorb/client.rb', line 32

def user
  @user
end

#users ⇒ Discorb::Dictionary{Discorb::Snowflake => Discorb::User} (readonly) 



36
37
38
 
# File 'lib/discorb/client.rb', line 36

def users
  @users
end

Instance Method Details

#close! ⇒ Object

Stops the client.



459
460
461
462
463
464
465
466
467
 
# File 'lib/discorb/client.rb', line 459

def close!
  if @shards.any?
    @shards.each(&:close!)
  else
    @connection.send_close
  end
  @tasks.each(&:stop)
  @status = :closed
end

#dispatch(event_name, *args) ⇒ Async::Task<void>

Dispatch an event.



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
 
# File 'lib/discorb/client.rb', line 171

def dispatch(event_name, *args)
  Async do
    if (conditions = @conditions[event_name])
      ids = Set[*conditions.map(&:first).map(&:object_id)]
      conditions.delete_if do |condition|
        next unless ids.include?(condition.first.object_id)

        check_result = condition[1].nil? || condition[1].call(*args)
        if check_result
          condition.first.signal(args)
          true
        else
          false
        end
      end
    end
    events = @events[event_name].dup || []
    if respond_to?("on_" + event_name.to_s)
      event_method = method("on_" + event_name.to_s)
      class << event_method
        def id
          "method"
        end
      end
      events << event_method
    end
    if events.nil?
      logger.debug "Event #{event_name} doesn't have any proc, skipping"
      next
    end
    logger.debug "Dispatching event #{event_name}"
    events.each do |block|
      Async do
        Async(annotation: "Discorb event: #{event_name}") do |_task|
          @events[event_name].delete(block) if block.is_a?(Discorb::EventHandler) && block.metadata[:once]
          block.call(*args)
          logger.debug "Dispatched proc with ID #{block.id.inspect}"
        rescue StandardError, ScriptError => e
          dispatch(:error, event_name, args, e)
        end
      end
    end
  end
end

#event_lock(event, timeout = nil, &check) ⇒ Async::Task<Object> Also known as: await

Method to wait for a event.

Raises:



354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
 
# File 'lib/discorb/client.rb', line 354

def event_lock(event, timeout = nil, &check)
  Async do |task|
    condition = Async::Condition.new
    @conditions[event] ||= []
    @conditions[event] << [condition, check]
    if timeout.nil?
      value = condition.wait
    else
      timeout_task = task.with_timeout(timeout) do
        condition.wait
      rescue Async::TimeoutError
        @conditions[event].delete_if { |c| c.first == condition }
        raise Discorb::TimeoutError, "Timeout waiting for event #{event}", cause: nil
      end
      value = timeout_task
    end
    value.length <= 1 ? value.first : value
  end
end

#fetch_application(force: false) ⇒ Async::Task<Discorb::Application>

Fetch webhook from ID. If application was cached, it will be used.



293
294
295
296
297
298
299
300
301
 
# File 'lib/discorb/client.rb', line 293

def fetch_application(force: false)
  Async do
    next @application if @application && !force

    _resp, data = @http.request(Route.new("/oauth2/applications/@me", "//oauth2/applications/@me", :get)).wait
    @application = Application.new(self, data)
    @application
  end
end

#fetch_channel(id) ⇒ Async::Task<Discorb::Channel>

Fetch channel from ID.

Raises:



243
244
245
246
247
248
 
# File 'lib/discorb/client.rb', line 243

def fetch_channel(id)
  Async do
    _resp, data = @http.request(Route.new("/channels/#{id}", "//channels/:channel_id", :get)).wait
    Channel.make_channel(self, data)
  end
end

#fetch_guild(id) ⇒ Async::Task<Discorb::Guild>

Fetch guild from ID.

Raises:



260
261
262
263
264
265
 
# File 'lib/discorb/client.rb', line 260

def fetch_guild(id)
  Async do
    _resp, data = @http.request(Route.new("/guilds/#{id}", "//guilds/:guild_id", :get)).wait
    Guild.new(self, data, false)
  end
end

#fetch_invite(code, with_count: true, with_expiration: true) ⇒ Async::Task<Discorb::Invite>

Fetch invite from code.



277
278
279
280
281
282
 
# File 'lib/discorb/client.rb', line 277

def fetch_invite(code, with_count: true, with_expiration: true)
  Async do
    _resp, data = @http.request(Route.new("/invites/#{code}?with_count=#{with_count}&with_expiration=#{with_expiration}", "//invites/:code", :get)).wait
    Invite.new(self, data, false)
  end
end

#fetch_nitro_sticker_packs ⇒ Async::Task<Array<Discorb::Sticker::Pack>>

Fetch nitro sticker pack from ID.



309
310
311
312
313
314
 
# File 'lib/discorb/client.rb', line 309

def fetch_nitro_sticker_packs
  Async do
    _resp, data = @http.request(Route.new("/sticker-packs", "//sticker-packs", :get)).wait
    data[:sticker_packs].map { |pack| Sticker::Pack.new(self, pack) }
  end
end

#fetch_user(id) ⇒ Async::Task<Discorb::User>

Fetch user from ID.

Raises:



226
227
228
229
230
231
 
# File 'lib/discorb/client.rb', line 226

def fetch_user(id)
  Async do
    _resp, data = @http.request(Route.new("/users/#{id}", "//users/:user_id", :get)).wait
    User.new(self, data)
  end
end

#inspect ⇒ Object 



376
377
378
 
# File 'lib/discorb/client.rb', line 376

def inspect
  "#<#{self.class} user=\"#{user}\">"
end

#load_extension(ext) ⇒ Object

Load the extension.



386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
 
# File 'lib/discorb/client.rb', line 386

def load_extension(ext, ...)
  case ext
  when Class
    raise ArgumentError, "#{ext} is not a extension" unless ext < Discorb::Extension
    ins = ext.new(self, ...)
  when Discorb::Extension
    ins = ext
  else
    raise ArgumentError, "#{ext} is not a extension"
  end

  @events.each_value do |event|
    event.delete_if { |c| c.metadata[:extension] == ins.class.name }
  end
  ins.events.each do |name, events|
    @events[name] ||= []
    events.each do |event|
      @events[name] << event
    end
  end
  @commands.delete_if do |cmd|
    cmd.respond_to? :extension and cmd.extension == ins.class.name
  end
  ins.class.commands.each do |cmd|
    cmd.define_singleton_method(:extension) { ins.class.name }
    cmd.replace_block(ins)
    cmd.block.define_singleton_method(:self_replaced) { true }
    @commands << cmd
  end

  cls = ins.class
  cls.loaded(self, ...) if cls.respond_to? :loaded
  ins.class.bottom_commands.each do |cmd|
    unless cmd.respond_to? :self_replaced
      cmd.define_singleton_method(:extension) { ins.class.name }
      cmd.replace_block(ins)
      cmd.block.define_singleton_method(:self_replaced) { true }
    end
    @bottom_commands << cmd
  end
  @extensions[ins.class.name] = ins
  ins
end

#on(event_name, id: nil, **metadata, &block) ⇒ Discorb::EventHandler

Registers an event handler.

See Also:



132
133
134
135
136
137
138
 
# File 'lib/discorb/client.rb', line 132

def on(event_name, id: nil, **metadata, &block)
  ne = EventHandler.new(block, id, metadata)
  @events[event_name] ||= []
  @events[event_name].delete_if { |e| e.metadata[:override] }
  @events[event_name] << ne
  ne
end

#once(event_name, id: nil, **metadata, &block) ⇒ Discorb::EventHandler

Almost same as #on, but only triggers the event once.



147
148
149
150
 
# File 'lib/discorb/client.rb', line 147

def once(event_name, id: nil, **metadata, &block)
  metadata[:once] = true
  on(event_name, id: id, **metadata, &block)
end

#remove_event(event_name, id) ⇒ Object

Remove event by ID.



158
159
160
 
# File 'lib/discorb/client.rb', line 158

def remove_event(event_name, id)
  @events[event_name].delete_if { |e| e.id == id }
end

#run(token = nil, shards: nil, shard_count: nil) ⇒ Object

Note:

This method behavior will change by CLI.

Note:

If the token is nil, you should use discorb run with the -e or --env option.

Starts the client.

Raises:

  • (ArgumentError)

See Also:



442
443
444
445
446
447
448
449
450
451
452
453
454
 
# File 'lib/discorb/client.rb', line 442

def run(token = nil, shards: nil, shard_count: nil)
  token ||= ENV["DISCORB_CLI_TOKEN"]
  raise ArgumentError, "Token is not specified, and -e/--env is not specified" if token.nil?
  case ENV["DISCORB_CLI_FLAG"]
  when nil
    start_client(token, shards: shards, shard_count: shard_count)
  when "run"
    before_run(token)
    start_client(token, shards: shards, shard_count: shard_count)
  when "setup"
    run_setup(token)
  end
end

#update_presence(activity = nil, status: nil) ⇒ Object Also known as: change_presence

Update presence of the client.



322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
 
# File 'lib/discorb/client.rb', line 322

def update_presence(activity = nil, status: nil)
  payload = {
    activities: [],
    status: status,
    since: nil,
    afk: nil,
  }
  payload[:activities] = [activity.to_hash] unless activity.nil?
  payload[:status] = status unless status.nil?
  if connection
    Async do
      send_gateway(3, **payload)
    end
  else
    @identify_presence = payload
  end
end