_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3 values | text stringlengths 66 10.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q12400 | Discordrb::Commands.CommandBot.trigger? | train | def trigger?(message)
if @prefix.is_a? String
standard_prefix_trigger(message.content, @prefix)
elsif @prefix.is_a? Array
@prefix.map { |e| standard_prefix_trigger(message.content, e) }.reduce { |m, e| m || e }
elsif @prefix.respond_to? :call
@prefix.call(message)
end
end | ruby | {
"resource": ""
} |
q12401 | Discordrb::Voice.VoiceBot.stop_playing | train | def stop_playing(wait_for_confirmation = false)
@was_playing_before = @playing
@speaking = false
@playing = false
sleep IDEAL_LENGTH / 1000.0 if @was_playing_before
return unless wait_for_confirmation
@has_stopped_playing = false
sleep IDEAL_LENGTH / 1000.0 until @has_stopped_playing
@has_stopped_playing = false
end | ruby | {
"resource": ""
} |
q12402 | Discordrb::Voice.VoiceBot.play_dca | train | def play_dca(file)
stop_playing(true) if @playing
@bot.debug "Reading DCA file #{file}"
input_stream = File.open(file)
magic = input_stream.read(4)
raise ArgumentError, 'Not a DCA1 file! The file might have been corrupted, please recreate it.' unless magic == 'DCA1'
# Read the metadata header, then read the metadata and discard it as we don't care about it
metadata_header = input_stream.read(4).unpack1('l<')
input_stream.read(metadata_header)
# Play the data, without re-encoding it to opus
play_internal do
begin
# Read header
header_str = input_stream.read(2)
unless header_str
@bot.debug 'Finished DCA parsing (header is nil)'
next :stop
end
header = header_str.unpack1('s<')
raise 'Negative header in DCA file! Your file is likely corrupted.' if header.negative?
rescue EOFError
@bot.debug 'Finished DCA parsing (EOFError)'
next :stop
end
# Read bytes
input_stream.read(header)
end
end | ruby | {
"resource": ""
} |
q12403 | Discordrb::Voice.VoiceBot.play_internal | train | def play_internal
count = 0
@playing = true
# Default play length (ms), will be adjusted later
@length = IDEAL_LENGTH
self.speaking = true
loop do
# Starting from the tenth packet, perform length adjustment every 100 packets (2 seconds)
should_adjust_this_packet = (count % @adjust_interval == @adjust_offset)
# If we should adjust, start now
@length_adjust = Time.now.nsec if should_adjust_this_packet
break unless @playing
# If we should skip, get some data, discard it and go to the next iteration
if @skips.positive?
@skips -= 1
yield
next
end
# Track packet count, sequence and time (Discord requires this)
count += 1
increment_packet_headers
# Get packet data
buf = yield
# Stop doing anything if the stop signal was sent
break if buf == :stop
# Proceed to the next packet if we got nil
next unless buf
# Track intermediate adjustment so we can measure how much encoding contributes to the total time
@intermediate_adjust = Time.now.nsec if should_adjust_this_packet
# Send the packet
@udp.send_audio(buf, @sequence, @time)
# Set the stream time (for tracking how long we've been playing)
@stream_time = count * @length / 1000
if @length_override # Don't do adjustment because the user has manually specified an override value
@length = @length_override
elsif @length_adjust # Perform length adjustment
# Define the time once so it doesn't get inaccurate
now = Time.now.nsec
# Difference between length_adjust and now in ms
ms_diff = (now - @length_adjust) / 1_000_000.0
if ms_diff >= 0
@length = if @adjust_average
(IDEAL_LENGTH - ms_diff + @length) / 2.0
else
IDEAL_LENGTH - ms_diff
end
# Track the time it took to encode
encode_ms = (@intermediate_adjust - @length_adjust) / 1_000_000.0
@bot.debug("Length adjustment: new length #{@length} (measured #{ms_diff}, #{(100 * encode_ms) / ms_diff}% encoding)") if @adjust_debug
end
@length_adjust = nil
end
# If paused, wait
sleep 0.1 while @paused
if @length.positive?
# Wait `length` ms, then send the next packet
sleep @length / 1000.0
else
Discordrb::LOGGER.warn('Audio encoding and sending together took longer than Discord expects one packet to be (20 ms)! This may be indicative of network problems.')
end
end
@bot.debug('Sending five silent frames to clear out buffers')
5.times do
increment_packet_headers
@udp.send_audio(Encoder::OPUS_SILENCE, @sequence, @time)
# Length adjustments don't matter here, we can just wait 20 ms since nobody is going to hear it anyway
sleep IDEAL_LENGTH / 1000.0
end
@bot.debug('Performing final cleanup after stream ended')
# Final cleanup
stop_playing
# Notify any stop_playing methods running right now that we have actually stopped
@has_stopped_playing = true
end | ruby | {
"resource": ""
} |
q12404 | Discordrb::Webhooks.Client.execute | train | def execute(builder = nil, wait = false)
raise TypeError, 'builder needs to be nil or like a Discordrb::Webhooks::Builder!' unless
builder.respond_to?(:file) && builder.respond_to?(:to_multipart_hash) || builder.respond_to?(:to_json_hash) || builder.nil?
builder ||= Builder.new
yield builder if block_given?
if builder.file
post_multipart(builder, wait)
else
post_json(builder, wait)
end
end | ruby | {
"resource": ""
} |
q12405 | Discordrb.Await.match | train | def match(event)
dummy_handler = EventContainer.handler_class(@type).new(@attributes, @bot)
return [nil, nil] unless event.instance_of?(@type) && dummy_handler.matches?(event)
should_delete = nil
should_delete = true if (@block && @block.call(event) != false) || !@block
[@key, should_delete]
end | ruby | {
"resource": ""
} |
q12406 | Discordrb::Events.Respondable.drain_into | train | def drain_into(result)
return if result.is_a?(Discordrb::Message)
result = (@saved_message.nil? ? '' : @saved_message.to_s) + (result.nil? ? '' : result.to_s)
drain
result
end | ruby | {
"resource": ""
} |
q12407 | Discordrb::Events.MessageEvent.attach_file | train | def attach_file(file, filename: nil, spoiler: nil)
raise ArgumentError, 'Argument is not a file!' unless file.is_a?(File)
@file = file
@filename = filename
@file_spoiler = spoiler
nil
end | ruby | {
"resource": ""
} |
q12408 | Discordrb.Server.role | train | def role(id)
id = id.resolve_id
@roles.find { |e| e.id == id }
end | ruby | {
"resource": ""
} |
q12409 | Discordrb.Server.member | train | def member(id, request = true)
id = id.resolve_id
return @members[id] if member_cached?(id)
return nil unless request
member = @bot.member(self, id)
@members[id] = member unless member.nil?
rescue StandardError
nil
end | ruby | {
"resource": ""
} |
q12410 | Discordrb.Server.prune_count | train | def prune_count(days)
raise ArgumentError, 'Days must be between 1 and 30' unless days.between?(1, 30)
response = JSON.parse API::Server.prune_count(@bot.token, @id, days)
response['pruned']
end | ruby | {
"resource": ""
} |
q12411 | Discordrb.Server.delete_role | train | def delete_role(role_id)
@roles.reject! { |r| r.id == role_id }
@members.each do |_, member|
new_roles = member.roles.reject { |r| r.id == role_id }
member.update_roles(new_roles)
end
@channels.each do |channel|
overwrites = channel.permission_overwrites.reject { |id, _| id == role_id }
channel.update_overwrites(overwrites)
end
end | ruby | {
"resource": ""
} |
q12412 | Discordrb.Server.update_role_positions | train | def update_role_positions(role_positions)
response = JSON.parse(API::Server.update_role_positions(@bot.token, @id, role_positions))
response.each do |data|
updated_role = Role.new(data, @bot, self)
role(updated_role.id).update_from(updated_role)
end
end | ruby | {
"resource": ""
} |
q12413 | Discordrb.Server.update_voice_state | train | def update_voice_state(data)
user_id = data['user_id'].to_i
if data['channel_id']
unless @voice_states[user_id]
# Create a new voice state for the user
@voice_states[user_id] = VoiceState.new(user_id)
end
# Update the existing voice state (or the one we just created)
channel = @channels_by_id[data['channel_id'].to_i]
@voice_states[user_id].update(
channel,
data['mute'],
data['deaf'],
data['self_mute'],
data['self_deaf']
)
else
# The user is not in a voice channel anymore, so delete its voice state
@voice_states.delete(user_id)
end
end | ruby | {
"resource": ""
} |
q12414 | Discordrb.Server.create_role | train | def create_role(name: 'new role', colour: 0, hoist: false, mentionable: false, permissions: 104_324_161, reason: nil)
colour = colour.respond_to?(:combined) ? colour.combined : colour
permissions = if permissions.is_a?(Array)
Permissions.bits(permissions)
elsif permissions.respond_to?(:bits)
permissions.bits
else
permissions
end
response = API::Server.create_role(@bot.token, @id, name, colour, hoist, mentionable, permissions, reason)
role = Role.new(JSON.parse(response), @bot, self)
@roles << role
role
end | ruby | {
"resource": ""
} |
q12415 | Discordrb.Server.add_emoji | train | def add_emoji(name, image, roles = [], reason: nil)
image_string = image
if image.respond_to? :read
image_string = 'data:image/jpg;base64,'
image_string += Base64.strict_encode64(image.read)
end
data = JSON.parse(API::Server.add_emoji(@bot.token, @id, image_string, name, roles.map(&:resolve_id), reason))
new_emoji = Emoji.new(data)
@emoji[new_emoji.id] = new_emoji
end | ruby | {
"resource": ""
} |
q12416 | Discordrb.Server.delete_emoji | train | def delete_emoji(emoji, reason: nil)
API::Server.delete_emoji(@bot.token, @id, emoji.resolve_id, reason)
end | ruby | {
"resource": ""
} |
q12417 | Discordrb.Server.ban | train | def ban(user, message_days = 0, reason: nil)
API::Server.ban_user(@bot.token, @id, user.resolve_id, message_days, reason)
end | ruby | {
"resource": ""
} |
q12418 | Discordrb.Server.unban | train | def unban(user, reason = nil)
API::Server.unban_user(@bot.token, @id, user.resolve_id, reason)
end | ruby | {
"resource": ""
} |
q12419 | Discordrb.Server.kick | train | def kick(user, reason = nil)
API::Server.remove_member(@bot.token, @id, user.resolve_id, reason)
end | ruby | {
"resource": ""
} |
q12420 | Discordrb.Server.move | train | def move(user, channel)
API::Server.update_member(@bot.token, @id, user.resolve_id, channel_id: channel.resolve_id)
end | ruby | {
"resource": ""
} |
q12421 | Discordrb.Server.icon= | train | def icon=(icon)
if icon.respond_to? :read
icon_string = 'data:image/jpg;base64,'
icon_string += Base64.strict_encode64(icon.read)
update_server_data(icon_id: icon_string)
else
update_server_data(icon_id: icon)
end
end | ruby | {
"resource": ""
} |
q12422 | Discordrb.Server.verification_level= | train | def verification_level=(level)
level = VERIFICATION_LEVELS[level] if level.is_a?(Symbol)
update_server_data(verification_level: level)
end | ruby | {
"resource": ""
} |
q12423 | Discordrb.Server.default_message_notifications= | train | def default_message_notifications=(notification_level)
notification_level = NOTIFICATION_LEVELS[notification_level] if notification_level.is_a?(Symbol)
update_server_data(default_message_notifications: notification_level)
end | ruby | {
"resource": ""
} |
q12424 | Discordrb.Server.explicit_content_filter= | train | def explicit_content_filter=(filter_level)
filter_level = FILTER_LEVELS[filter_level] if filter_level.is_a?(Symbol)
update_server_data(explicit_content_filter: filter_level)
end | ruby | {
"resource": ""
} |
q12425 | Discordrb.Server.webhooks | train | def webhooks
webhooks = JSON.parse(API::Server.webhooks(@bot.token, @id))
webhooks.map { |webhook| Webhook.new(webhook, @bot) }
end | ruby | {
"resource": ""
} |
q12426 | Discordrb.Server.invites | train | def invites
invites = JSON.parse(API::Server.invites(@bot.token, @id))
invites.map { |invite| Invite.new(invite, @bot) }
end | ruby | {
"resource": ""
} |
q12427 | Discordrb.Server.process_chunk | train | def process_chunk(members)
process_members(members)
@processed_chunk_members += members.length
LOGGER.debug("Processed one chunk on server #{@id} - length #{members.length}")
# Don't bother with the rest of the method if it's not truly the last packet
return unless @processed_chunk_members == @member_count
LOGGER.debug("Finished chunking server #{@id}")
# Reset everything to normal
@chunked = true
@processed_chunk_members = 0
end | ruby | {
"resource": ""
} |
q12428 | Discordrb::Voice.Encoder.adjust_volume | train | def adjust_volume(buf, mult)
# We don't need to adjust anything if the buf is nil so just return in that case
return unless buf
# buf is s16le so use 's<' for signed, 16 bit, LE
result = buf.unpack('s<*').map do |sample|
sample *= mult
# clamp to s16 range
[32_767, [-32_768, sample].max].min
end
# After modification, make it s16le again
result.pack('s<*')
end | ruby | {
"resource": ""
} |
q12429 | Discordrb::Commands.CommandContainer.command | train | def command(name, attributes = {}, &block)
@commands ||= {}
if name.is_a? Array
new_command = nil
name.each do |e|
new_command = Command.new(e, attributes, &block)
@commands[e] = new_command
end
new_command
else
new_command = Command.new(name, attributes, &block)
new_command.attributes[:aliases].each do |aliased_name|
@commands[aliased_name] = CommandAlias.new(aliased_name, new_command)
end
@commands[name] = new_command
end
end | ruby | {
"resource": ""
} |
q12430 | Discordrb.Profile.avatar= | train | def avatar=(avatar)
if avatar.respond_to? :read
# Set the file to binary mode if supported, so we don't get problems with Windows
avatar.binmode if avatar.respond_to?(:binmode)
avatar_string = 'data:image/jpg;base64,'
avatar_string += Base64.strict_encode64(avatar.read)
update_profile_data(avatar: avatar_string)
else
update_profile_data(avatar: avatar)
end
end | ruby | {
"resource": ""
} |
q12431 | Discordrb::Voice.VoiceUDP.connect | train | def connect(endpoint, port, ssrc)
@endpoint = endpoint
@endpoint = @endpoint[6..-1] if @endpoint.start_with? 'wss://'
@endpoint = @endpoint.gsub(':80', '') # The endpoint may contain a port, we don't want that
@endpoint = Resolv.getaddress @endpoint
@port = port
@ssrc = ssrc
end | ruby | {
"resource": ""
} |
q12432 | Discordrb::Voice.VoiceUDP.receive_discovery_reply | train | def receive_discovery_reply
# Wait for a UDP message
message = @socket.recv(70)
ip = message[4..-3].delete("\0")
port = message[-2..-1].to_i
[ip, port]
end | ruby | {
"resource": ""
} |
q12433 | Discordrb::Voice.VoiceUDP.send_audio | train | def send_audio(buf, sequence, time)
# Header of the audio packet
header = [0x80, 0x78, sequence, time, @ssrc].pack('CCnNN')
# Encrypt data, if necessary
buf = encrypt_audio(header, buf) if encrypted?
send_packet(header + buf)
end | ruby | {
"resource": ""
} |
q12434 | Discordrb::Voice.VoiceUDP.encrypt_audio | train | def encrypt_audio(header, buf)
raise 'No secret key found, despite encryption being enabled!' unless @secret_key
box = RbNaCl::SecretBox.new(@secret_key)
# The nonce is the header of the voice packet with 12 null bytes appended
nonce = header + ([0] * 12).pack('C*')
box.encrypt(nonce, buf)
end | ruby | {
"resource": ""
} |
q12435 | Discordrb::Commands.RateLimiter.rate_limited? | train | def rate_limited?(key, thing, increment: 1)
# Check whether the bucket actually exists
return false unless @buckets && @buckets[key]
@buckets[key].rate_limited?(thing, increment: increment)
end | ruby | {
"resource": ""
} |
q12436 | Discordrb::Commands.Bucket.clean | train | def clean(rate_limit_time = nil)
rate_limit_time ||= Time.now
@bucket.delete_if do |_, limit_hash|
# Time limit has not run out
return false if @time_span && rate_limit_time < (limit_hash[:set_time] + @time_span)
# Delay has not run out
return false if @delay && rate_limit_time < (limit_hash[:last_time] + @delay)
true
end
end | ruby | {
"resource": ""
} |
q12437 | Discordrb::Commands.Bucket.rate_limited? | train | def rate_limited?(thing, rate_limit_time = nil, increment: 1)
key = resolve_key thing
limit_hash = @bucket[key]
# First case: limit_hash doesn't exist yet
unless limit_hash
@bucket[key] = {
last_time: Time.now,
set_time: Time.now,
count: increment
}
return false
end
# Define the time at which we're being rate limited once so it doesn't get inaccurate
rate_limit_time ||= Time.now
if @limit && (limit_hash[:count] + increment) > @limit
# Second case: Count is over the limit and the time has not run out yet
return (limit_hash[:set_time] + @time_span) - rate_limit_time if @time_span && rate_limit_time < (limit_hash[:set_time] + @time_span)
# Third case: Count is over the limit but the time has run out
# Don't return anything here because there may still be delay-based limiting
limit_hash[:set_time] = rate_limit_time
limit_hash[:count] = 0
end
if @delay && rate_limit_time < (limit_hash[:last_time] + @delay)
# Fourth case: we're being delayed
(limit_hash[:last_time] + @delay) - rate_limit_time
else
# Fifth case: no rate limiting at all! Increment the count, set the last_time, and return false
limit_hash[:last_time] = rate_limit_time
limit_hash[:count] += increment
false
end
end | ruby | {
"resource": ""
} |
q12438 | Discordrb.Gateway.run_async | train | def run_async
@ws_thread = Thread.new do
Thread.current[:discordrb_name] = 'websocket'
connect_loop
LOGGER.warn('The WS loop exited! Not sure if this is a good thing')
end
LOGGER.debug('WS thread created! Now waiting for confirmation that everything worked')
sleep(0.5) until @ws_success
LOGGER.debug('Confirmation received! Exiting run.')
end | ruby | {
"resource": ""
} |
q12439 | Discordrb.Gateway.send_packet | train | def send_packet(opcode, packet)
data = {
op: opcode,
d: packet
}
send(data.to_json)
end | ruby | {
"resource": ""
} |
q12440 | Discordrb.Gateway.obtain_socket | train | def obtain_socket(uri)
socket = TCPSocket.new(uri.host, uri.port || socket_port(uri))
if secure_uri?(uri)
ctx = OpenSSL::SSL::SSLContext.new
if ENV['DISCORDRB_SSL_VERIFY_NONE']
ctx.ssl_version = 'SSLv23'
ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE # use VERIFY_PEER for verification
cert_store = OpenSSL::X509::Store.new
cert_store.set_default_paths
ctx.cert_store = cert_store
else
ctx.set_params ssl_version: :TLSv1_2
end
socket = OpenSSL::SSL::SSLSocket.new(socket, ctx)
socket.connect
end
socket
end | ruby | {
"resource": ""
} |
q12441 | Committee.SchemaValidator::HyperSchema::ResponseValidator.target_schema | train | def target_schema(link)
if link.target_schema
link.target_schema
elsif legacy_hyper_schema_rel?(link)
link.parent
end
end | ruby | {
"resource": ""
} |
q12442 | FFaker.NameMX.name | train | def name(gender = :any)
case gender
when :any then rand(0..1) == 0 ? name(:male) : name(:female)
when :male then fetch_sample(MALE_FIRST_NAMES)
when :female then fetch_sample(FEMALE_FIRST_NAMES)
else raise ArgumentError, 'Invalid gender, must be one of :any, :male, :female'
end
end | ruby | {
"resource": ""
} |
q12443 | FFaker.PhoneNumberDE.mobile_prefix | train | def mobile_prefix(leading_zero = true)
mobile_prefix = '1' + rand(5..7).to_s + rand(0..9).to_s
mobile_prefix = '0' + mobile_prefix if leading_zero
mobile_prefix
end | ruby | {
"resource": ""
} |
q12444 | MiniMagick.Image.validate! | train | def validate!
identify
rescue MiniMagick::Error => error
raise MiniMagick::Invalid, error.message
end | ruby | {
"resource": ""
} |
q12445 | MiniMagick.Image.format | train | def format(format, page = 0, read_opts={})
if @tempfile
new_tempfile = MiniMagick::Utilities.tempfile(".#{format}")
new_path = new_tempfile.path
else
new_path = Pathname(path).sub_ext(".#{format}").to_s
end
input_path = path.dup
input_path << "[#{page}]" if page && !layer?
MiniMagick::Tool::Convert.new do |convert|
read_opts.each do |opt, val|
convert.send(opt.to_s, val)
end
convert << input_path
yield convert if block_given?
convert << new_path
end
if @tempfile
destroy!
@tempfile = new_tempfile
else
File.delete(path) unless path == new_path || layer?
end
path.replace new_path
@info.clear
self
end | ruby | {
"resource": ""
} |
q12446 | MiniMagick.Image.identify | train | def identify
MiniMagick::Tool::Identify.new do |builder|
yield builder if block_given?
builder << path
end
end | ruby | {
"resource": ""
} |
q12447 | Excon.Utils.redact | train | def redact(datum)
datum = datum.dup
if datum.has_key?(:headers) && datum[:headers].has_key?('Authorization')
datum[:headers] = datum[:headers].dup
datum[:headers]['Authorization'] = REDACTED
end
if datum.has_key?(:password)
datum[:password] = REDACTED
end
datum
end | ruby | {
"resource": ""
} |
q12448 | Excon.Utils.split_header_value | train | def split_header_value(str)
return [] if str.nil?
str = str.dup.strip
binary_encode(str)
str.scan(%r'\G((?:"(?:\\.|[^"])+?"|[^",]+)+)
(?:,\s*|\Z)'xn).flatten
end | ruby | {
"resource": ""
} |
q12449 | Excon.Utils.escape_uri | train | def escape_uri(str)
str = str.dup
binary_encode(str)
str.gsub(UNESCAPED) { "%%%02X" % $1[0].ord }
end | ruby | {
"resource": ""
} |
q12450 | Excon.Utils.unescape_uri | train | def unescape_uri(str)
str = str.dup
binary_encode(str)
str.gsub(ESCAPED) { $1.hex.chr }
end | ruby | {
"resource": ""
} |
q12451 | Excon.Utils.unescape_form | train | def unescape_form(str)
str = str.dup
binary_encode(str)
str.gsub!(/\+/, ' ')
str.gsub(ESCAPED) { $1.hex.chr }
end | ruby | {
"resource": ""
} |
q12452 | Excon.Connection.request | train | def request(params={}, &block)
# @data has defaults, merge in new params to override
datum = @data.merge(params)
datum[:headers] = @data[:headers].merge(datum[:headers] || {})
validate_params(:request, params, datum[:middlewares])
# If the user passed in new middleware, we want to validate that the original connection parameters
# are still valid with the provided middleware.
if params[:middlewares]
validate_params(:connection, @data, datum[:middlewares])
end
if datum[:user] || datum[:password]
user, pass = Utils.unescape_uri(datum[:user].to_s), Utils.unescape_uri(datum[:password].to_s)
datum[:headers]['Authorization'] ||= 'Basic ' + ["#{user}:#{pass}"].pack('m').delete(Excon::CR_NL)
end
if datum[:scheme] == UNIX
datum[:headers]['Host'] ||= ''
else
datum[:headers]['Host'] ||= datum[:host] + port_string(datum)
end
# if path is empty or doesn't start with '/', insert one
unless datum[:path][0, 1] == '/'
datum[:path] = datum[:path].dup.insert(0, '/')
end
if block_given?
Excon.display_warning('Excon requests with a block are deprecated, pass :response_block instead.')
datum[:response_block] = Proc.new
end
datum[:connection] = self
datum[:stack] = datum[:middlewares].map do |middleware|
lambda {|stack| middleware.new(stack)}
end.reverse.inject(self) do |middlewares, middleware|
middleware.call(middlewares)
end
datum = datum[:stack].request_call(datum)
unless datum[:pipeline]
datum = response(datum)
if datum[:persistent]
if key = datum[:response][:headers].keys.detect {|k| k.casecmp('Connection') == 0 }
if datum[:response][:headers][key].casecmp('close') == 0
reset
end
end
else
reset
end
Excon::Response.new(datum[:response])
else
datum
end
rescue => error
reset
# If we didn't get far enough to initialize datum and the middleware stack, just raise
raise error if !datum
datum[:error] = error
if datum[:stack]
datum[:stack].error_call(datum)
else
raise error
end
end | ruby | {
"resource": ""
} |
q12453 | Excon.Connection.requests | train | def requests(pipeline_params)
pipeline_params.each {|params| params.merge!(:pipeline => true, :persistent => true) }
pipeline_params.last.merge!(:persistent => @data[:persistent])
responses = pipeline_params.map do |params|
request(params)
end.map do |datum|
Excon::Response.new(response(datum)[:response])
end
if @data[:persistent]
if key = responses.last[:headers].keys.detect {|k| k.casecmp('Connection') == 0 }
if responses.last[:headers][key].casecmp('close') == 0
reset
end
end
else
reset
end
responses
end | ruby | {
"resource": ""
} |
q12454 | Excon.Connection.batch_requests | train | def batch_requests(pipeline_params, limit = nil)
limit ||= Process.respond_to?(:getrlimit) ? Process.getrlimit(:NOFILE).first : 256
responses = []
pipeline_params.each_slice(limit) do |params|
responses.concat(requests(params))
end
responses
end | ruby | {
"resource": ""
} |
q12455 | Aruba.Console.start | train | def start
# Start IRB with current context:
# http://stackoverflow.com/questions/4189818/how-to-run-irb-start-in-context-of-current-class
ARGV.clear
IRB.setup nil
IRB.conf[:IRB_NAME] = 'aruba'
IRB.conf[:PROMPT] = {}
IRB.conf[:PROMPT][:ARUBA] = {
PROMPT_I: '%N:%03n:%i> ',
PROMPT_S: '%N:%03n:%i%l ',
PROMPT_C: '%N:%03n:%i* ',
RETURN: "# => %s\n"
}
IRB.conf[:PROMPT_MODE] = :ARUBA
IRB.conf[:RC] = false
require 'irb/completion'
require 'irb/ext/save-history'
IRB.conf[:READLINE] = true
IRB.conf[:SAVE_HISTORY] = 1000
IRB.conf[:HISTORY_FILE] = Aruba.config.console_history_file
context = Class.new do
include Aruba::Api
include Aruba::Console::Help
def initialize
setup_aruba
end
def inspect
'nil'
end
end
irb = IRB::Irb.new(IRB::WorkSpace.new(context.new))
IRB.conf[:MAIN_CONTEXT] = irb.context
trap("SIGINT") do
irb.signal_handle
end
begin
catch(:IRB_EXIT) do
irb.eval_input
end
ensure
IRB.irb_at_exit
end
end | ruby | {
"resource": ""
} |
q12456 | Aruba.BasicConfiguration.make_copy | train | def make_copy
obj = self.dup
obj.local_options = Marshal.load(Marshal.dump(local_options))
obj.hooks = @hooks
obj
end | ruby | {
"resource": ""
} |
q12457 | Aruba.BasicConfiguration.before | train | def before(name, context = proc {}, *args, &block)
name = format('%s_%s', 'before_', name.to_s).to_sym
if block_given?
@hooks.append(name, block)
self
else
@hooks.execute(name, context, *args)
end
end | ruby | {
"resource": ""
} |
q12458 | Aruba.EventBus.notify | train | def notify(event)
fail NoEventError, 'Please pass an event object, not a class' if event.is_a?(Class)
@handlers[event.class.to_s].each { |handler| handler.call(event) }
end | ruby | {
"resource": ""
} |
q12459 | Aruba.Runtime.fixtures_directory | train | def fixtures_directory
@fixtures_directory ||= begin
candidates = config.fixtures_directories.map { |dir| File.join(root_directory, dir) }
directory = candidates.find { |d| Aruba.platform.directory? d }
fail "No existing fixtures directory found in #{candidates.map { |d| format('"%s"', d) }.join(', ')}." unless directory
directory
end
fail %(Fixtures directory "#{@fixtures_directory}" is not a directory) unless Aruba.platform.directory?(@fixtures_directory)
ArubaPath.new(@fixtures_directory)
end | ruby | {
"resource": ""
} |
q12460 | Aruba.Initializer.call | train | def call(test_framework)
begin
initializers.find { |i| i.match? test_framework }.start [], {}
rescue ArgumentError => e
$stderr.puts e.message
exit 0
end
Initializers::CommonInitializer.start [], {}
end | ruby | {
"resource": ""
} |
q12461 | Aruba.Hooks.append | train | def append(label, block)
if store.key?(label.to_sym) && store[label.to_sym].respond_to?(:<<)
store[label.to_sym] << block
else
store[label.to_sym] = []
store[label.to_sym] << block
end
end | ruby | {
"resource": ""
} |
q12462 | Fui.Finder.find | train | def find(path)
results = []
Find.find(path) do |fpath|
if FileTest.directory?(fpath)
next unless ignores
ignores.each do |ignore|
next unless fpath.include?(ignore.realpath.to_s)
puts "Ignoring Directory: #{fpath}" if options[:verbose]
Find.prune
end
end
results << fpath if yield fpath
end
results
end | ruby | {
"resource": ""
} |
q12463 | SidekiqUniqueJobs.Util.keys | train | def keys(pattern = SCAN_PATTERN, count = DEFAULT_COUNT)
return redis(&:keys) if pattern.nil?
redis { |conn| conn.scan_each(match: prefix(pattern), count: count).to_a }
end | ruby | {
"resource": ""
} |
q12464 | SidekiqUniqueJobs.Util.keys_with_ttl | train | def keys_with_ttl(pattern = SCAN_PATTERN, count = DEFAULT_COUNT)
hash = {}
redis do |conn|
conn.scan_each(match: prefix(pattern), count: count).each do |key|
hash[key] = conn.ttl(key)
end
end
hash
end | ruby | {
"resource": ""
} |
q12465 | SidekiqUniqueJobs.Util.del | train | def del(pattern = SCAN_PATTERN, count = 0)
raise ArgumentError, "Please provide a number of keys to delete greater than zero" if count.zero?
pattern = suffix(pattern)
log_debug { "Deleting keys by: #{pattern}" }
keys, time = timed { keys(pattern, count) }
key_size = keys.size
log_debug { "#{key_size} keys found in #{time} sec." }
_, time = timed { batch_delete(keys) }
log_debug { "Deleted #{key_size} keys in #{time} sec." }
key_size
end | ruby | {
"resource": ""
} |
q12466 | SidekiqUniqueJobs.Unlockable.unlock | train | def unlock(item)
SidekiqUniqueJobs::UniqueArgs.digest(item)
SidekiqUniqueJobs::Locksmith.new(item).unlock
end | ruby | {
"resource": ""
} |
q12467 | SidekiqUniqueJobs.Unlockable.delete | train | def delete(item)
SidekiqUniqueJobs::UniqueArgs.digest(item)
SidekiqUniqueJobs::Locksmith.new(item).delete!
end | ruby | {
"resource": ""
} |
q12468 | SidekiqUniqueJobs.Scripts.call | train | def call(file_name, redis_pool, options = {})
execute_script(file_name, redis_pool, options)
rescue Redis::CommandError => ex
handle_error(ex, file_name) do
call(file_name, redis_pool, options)
end
end | ruby | {
"resource": ""
} |
q12469 | SidekiqUniqueJobs.Scripts.execute_script | train | def execute_script(file_name, redis_pool, options = {})
redis(redis_pool) do |conn|
sha = script_sha(conn, file_name)
conn.evalsha(sha, options)
end
end | ruby | {
"resource": ""
} |
q12470 | SidekiqUniqueJobs.Scripts.script_sha | train | def script_sha(conn, file_name)
if (sha = SCRIPT_SHAS.get(file_name))
return sha
end
sha = conn.script(:load, script_source(file_name))
SCRIPT_SHAS.put(file_name, sha)
sha
end | ruby | {
"resource": ""
} |
q12471 | SidekiqUniqueJobs.Scripts.handle_error | train | def handle_error(ex, file_name)
if ex.message == "NOSCRIPT No matching script. Please use EVAL."
SCRIPT_SHAS.delete(file_name)
return yield if block_given?
end
raise ScriptError, file_name: file_name, source_exception: ex
end | ruby | {
"resource": ""
} |
q12472 | SidekiqUniqueJobs.Locksmith.delete! | train | def delete!
Scripts.call(
:delete,
redis_pool,
keys: [exists_key, grabbed_key, available_key, version_key, UNIQUE_SET, unique_digest],
)
end | ruby | {
"resource": ""
} |
q12473 | SidekiqUniqueJobs.Locksmith.lock | train | def lock(timeout = nil, &block)
Scripts.call(:lock, redis_pool,
keys: [exists_key, grabbed_key, available_key, UNIQUE_SET, unique_digest],
argv: [jid, ttl, lock_type])
grab_token(timeout) do |token|
touch_grabbed_token(token)
return_token_or_block_value(token, &block)
end
end | ruby | {
"resource": ""
} |
q12474 | SidekiqUniqueJobs.Locksmith.unlock! | train | def unlock!(token = nil)
token ||= jid
Scripts.call(
:unlock,
redis_pool,
keys: [exists_key, grabbed_key, available_key, version_key, UNIQUE_SET, unique_digest],
argv: [token, ttl, lock_type],
)
end | ruby | {
"resource": ""
} |
q12475 | SidekiqUniqueJobs.Connection.redis | train | def redis(redis_pool = nil)
if redis_pool
redis_pool.with { |conn| yield conn }
else
Sidekiq.redis { |conn| yield conn }
end
end | ruby | {
"resource": ""
} |
q12476 | SidekiqUniqueJobs.Digests.all | train | def all(pattern: SCAN_PATTERN, count: DEFAULT_COUNT)
redis { |conn| conn.sscan_each(UNIQUE_SET, match: pattern, count: count).to_a }
end | ruby | {
"resource": ""
} |
q12477 | SidekiqUniqueJobs.Digests.page | train | def page(pattern: SCAN_PATTERN, cursor: 0, page_size: 100)
redis do |conn|
total_size, digests = conn.multi do
conn.scard(UNIQUE_SET)
conn.sscan(UNIQUE_SET, cursor, match: pattern, count: page_size)
end
[total_size, digests[0], digests[1]]
end
end | ruby | {
"resource": ""
} |
q12478 | SidekiqUniqueJobs.Digests.del | train | def del(digest: nil, pattern: nil, count: DEFAULT_COUNT)
return delete_by_pattern(pattern, count: count) if pattern
return delete_by_digest(digest) if digest
raise ArgumentError, "either digest or pattern need to be provided"
end | ruby | {
"resource": ""
} |
q12479 | SidekiqUniqueJobs.Digests.delete_by_pattern | train | def delete_by_pattern(pattern, count: DEFAULT_COUNT)
result, elapsed = timed do
digests = all(pattern: pattern, count: count)
batch_delete(digests)
digests.size
end
log_info("#{__method__}(#{pattern}, count: #{count}) completed in #{elapsed}ms")
result
end | ruby | {
"resource": ""
} |
q12480 | SidekiqUniqueJobs.Digests.delete_by_digest | train | def delete_by_digest(digest)
result, elapsed = timed do
Scripts.call(:delete_by_digest, nil, keys: [UNIQUE_SET, digest])
count
end
log_info("#{__method__}(#{digest}) completed in #{elapsed}ms")
result
end | ruby | {
"resource": ""
} |
q12481 | SidekiqUniqueJobs.SidekiqWorkerMethods.worker_class_constantize | train | def worker_class_constantize(klazz = @worker_class)
return klazz unless klazz.is_a?(String)
Object.const_get(klazz)
rescue NameError => ex
case ex.message
when /uninitialized constant/
klazz
else
raise
end
end | ruby | {
"resource": ""
} |
q12482 | SidekiqUniqueJobs.Config.add_lock | train | def add_lock(name, klass)
raise ArgumentError, "Lock #{name} already defined, please use another name" if locks.key?(name.to_sym)
new_locks = locks.dup.merge(name.to_sym => klass).freeze
self.locks = new_locks
end | ruby | {
"resource": ""
} |
q12483 | SidekiqUniqueJobs.Config.add_strategy | train | def add_strategy(name, klass)
raise ArgumentError, "strategy #{name} already defined, please use another name" if strategies.key?(name.to_sym)
new_strategies = strategies.dup.merge(name.to_sym => klass).freeze
self.strategies = new_strategies
end | ruby | {
"resource": ""
} |
q12484 | SidekiqUniqueJobs.UniqueArgs.digestable_hash | train | def digestable_hash
@item.slice(CLASS_KEY, QUEUE_KEY, UNIQUE_ARGS_KEY).tap do |hash|
hash.delete(QUEUE_KEY) if unique_across_queues?
hash.delete(CLASS_KEY) if unique_across_workers?
end
end | ruby | {
"resource": ""
} |
q12485 | SidekiqUniqueJobs.UniqueArgs.filtered_args | train | def filtered_args(args)
return args if args.empty?
json_args = Normalizer.jsonify(args)
case unique_args_method
when Proc
filter_by_proc(json_args)
when Symbol
filter_by_symbol(json_args)
else
log_debug("#{__method__} arguments not filtered (using all arguments for uniqueness)")
json_args
end
end | ruby | {
"resource": ""
} |
q12486 | SidekiqUniqueJobs.UniqueArgs.filter_by_symbol | train | def filter_by_symbol(args)
return args unless worker_method_defined?(unique_args_method)
worker_class.send(unique_args_method, args)
rescue ArgumentError => ex
log_fatal(ex)
args
end | ruby | {
"resource": ""
} |
q12487 | Awspec::Helper.ClientWrap.method_missing | train | def method_missing(m, *args, &block)
begin
results = client.send(m, *args, &block)
rescue Exception => e # rubocop:disable Lint/RescueException
raise unless e.class.to_s == symbol.to_s && backoff < backoff_limit
@backoff = backoff + (iteration * iteration * 0.5)
@iteration += 1
sleep backoff
results = self.send(m, *args, &block)
end
reset_backoff
results
end | ruby | {
"resource": ""
} |
q12488 | Logidze.History.changes_to | train | def changes_to(time: nil, version: nil, data: {}, from: 0)
raise ArgumentError, "Time or version must be specified" if time.nil? && version.nil?
filter = time.nil? ? method(:version_filter) : method(:time_filter)
versions.each_with_object(data.dup) do |v, acc|
next if v.version < from
break acc if filter.call(v, version, time)
acc.merge!(v.changes)
end
end | ruby | {
"resource": ""
} |
q12489 | Logidze.History.diff_from | train | def diff_from(time: nil, version: nil)
raise ArgumentError, "Time or version must be specified" if time.nil? && version.nil?
from_version = version.nil? ? find_by_time(time) : find_by_version(version)
from_version ||= versions.first
base = changes_to(version: from_version.version)
diff = changes_to(version: self.version, data: base, from: from_version.version + 1)
build_changes(base, diff)
end | ruby | {
"resource": ""
} |
q12490 | Logidze.History.current_ts? | train | def current_ts?(time)
(current_version.time <= time) &&
(next_version.nil? || (next_version.time < time))
end | ruby | {
"resource": ""
} |
q12491 | Logidze.Model.at_version | train | def at_version(version)
return self if log_data.version == version
log_entry = log_data.find_by_version(version)
return nil unless log_entry
build_dup(log_entry)
end | ruby | {
"resource": ""
} |
q12492 | Logidze.Model.diff_from | train | def diff_from(ts = nil, version: nil, time: nil)
Deprecations.show_ts_deprecation_for("#diff_from") if ts
time ||= ts
time = parse_time(time) if time
changes = log_data.diff_from(time: time, version: version).tap do |v|
deserialize_changes!(v)
end
changes.delete_if { |k, _v| deleted_column?(k) }
{ "id" => id, "changes" => changes }
end | ruby | {
"resource": ""
} |
q12493 | Logidze.Model.undo! | train | def undo!(append: Logidze.append_on_undo)
version = log_data.previous_version
return false if version.nil?
switch_to!(version.version, append: append)
end | ruby | {
"resource": ""
} |
q12494 | Logidze.Model.switch_to! | train | def switch_to!(version, append: Logidze.append_on_undo)
return false unless at_version(version)
if append && version < log_version
update!(log_data.changes_to(version: version))
else
at_version!(version)
self.class.without_logging { save! }
end
end | ruby | {
"resource": ""
} |
q12495 | MarkdownLint.Doc.find_type | train | def find_type(type, nested=true)
find_type_elements(type, nested).map { |e| e.options }
end | ruby | {
"resource": ""
} |
q12496 | MarkdownLint.Doc.find_type_elements | train | def find_type_elements(type, nested=true, elements=@elements)
results = []
if type.class == Symbol
type = [type]
end
elements.each do |e|
results.push(e) if type.include?(e.type)
if nested and not e.children.empty?
results.concat(find_type_elements(type, nested, e.children))
end
end
results
end | ruby | {
"resource": ""
} |
q12497 | MarkdownLint.Doc.find_type_elements_except | train | def find_type_elements_except(type, nested_except=[], elements=@elements)
results = []
if type.class == Symbol
type = [type]
end
if nested_except.class == Symbol
nested_except = [nested_except]
end
elements.each do |e|
results.push(e) if type.include?(e.type)
unless nested_except.include?(e.type) or e.children.empty?
results.concat(find_type_elements_except(type, nested_except, e.children))
end
end
results
end | ruby | {
"resource": ""
} |
q12498 | MarkdownLint.Doc.element_linenumber | train | def element_linenumber(element)
element = element.options if element.is_a?(Kramdown::Element)
element[:location]
end | ruby | {
"resource": ""
} |
q12499 | MarkdownLint.Doc.matching_lines | train | def matching_lines(re)
@lines.each_with_index.select{|text, linenum| re.match(text)}.map{
|i| i[1]+1}
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.