_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q21100 | ROS.ParameterManager.get_param_names | train | def get_param_names
code, message, value = @server.call("getParamNames", @caller_id)
case code
when 1
return value
when -1
| ruby | {
"resource": ""
} |
q21101 | ROS.Time.- | train | def -(other)
d = ::ROS::Duration.new
d.secs = @secs - other.secs
| ruby | {
"resource": ""
} |
q21102 | ROS::TCPROS.ServiceClient.call | train | def call(srv_request, srv_response)
write_header(@socket, build_header)
if check_header(read_header(@socket))
write_msg(@socket, srv_request) | ruby | {
"resource": ""
} |
q21103 | ROS.Master.kill_same_name_node | train | def kill_same_name_node(caller_id, api)
delete_api = nil
[@publishers, @subscribers, @services].each do |list|
list.each do |pub|
if pub.caller_id == caller_id and pub.api != api
puts "killing #{caller_id}"
delete_api = pub.api
break
end
... | ruby | {
"resource": ""
} |
q21104 | ROS.GraphManager.get_available_port | train | def get_available_port
server = TCPServer.open(0)
saddr = server.getsockname | ruby | {
"resource": ""
} |
q21105 | ROS.GraphManager.wait_for_service | train | def wait_for_service(service_name, timeout_sec)
begin
timeout(timeout_sec) do
while @is_ok
if @master.lookup_service(service_name)
return true
| ruby | {
"resource": ""
} |
q21106 | ROS.GraphManager.add_service_server | train | def add_service_server(service_server)
@master.register_service(service_server.service_name,
| ruby | {
"resource": ""
} |
q21107 | ROS.GraphManager.add_subscriber | train | def add_subscriber(subscriber)
uris = @master.register_subscriber(subscriber.topic_name,
subscriber.topic_type.type)
subscriber.set_manager(self)
uris.each do |publisher_uri|
| ruby | {
"resource": ""
} |
q21108 | ROS.GraphManager.add_parameter_subscriber | train | def add_parameter_subscriber(subscriber)
subscriber.set_manager(self)
@parameter_subscribers.push(subscriber)
| ruby | {
"resource": ""
} |
q21109 | ROS.GraphManager.add_publisher | train | def add_publisher(publisher)
@master.register_publisher(publisher.topic_name,
| ruby | {
"resource": ""
} |
q21110 | ROS.GraphManager.shutdown_publisher | train | def shutdown_publisher(publisher)
begin
@master.unregister_publisher(publisher.topic_name)
ensure
@publishers.delete(publisher) do |pub| | ruby | {
"resource": ""
} |
q21111 | ROS.GraphManager.shutdown_subscriber | train | def shutdown_subscriber(subscriber)
begin
@master.unregister_subscriber(subscriber.topic_name)
@subscribers.delete(subscriber) do |pub|
| ruby | {
"resource": ""
} |
q21112 | ROS.GraphManager.shutdown_service_server | train | def shutdown_service_server(service)
begin
@master.unregister_service(service.service_name,
| ruby | {
"resource": ""
} |
q21113 | ROS::TCPROS.Client.start | train | def start
write_header(@socket, build_header)
read_header(@socket)
@thread = Thread.start do
while @is_running
data = read_all(@socket)
msg = @topic_type.new
| ruby | {
"resource": ""
} |
q21114 | ROS::TCPROS.Message.write_msg | train | def write_msg(socket, msg)
sio = StringIO.new('', 'r+')
len = msg.serialize(sio)
sio.rewind
data = sio.read
| ruby | {
"resource": ""
} |
q21115 | ROS::TCPROS.Message.read_all | train | def read_all(socket)
total_bytes = socket.recv(4).unpack("V")[0]
| ruby | {
"resource": ""
} |
q21116 | ROS::TCPROS.Message.read_header | train | def read_header(socket)
header = ::ROS::TCPROS::Header.new
| ruby | {
"resource": ""
} |
q21117 | ROS::TCPROS.Header.push_data | train | def push_data(key, value)
if (not key.kind_of?(String)) or (not value.kind_of?(String))
raise | ruby | {
"resource": ""
} |
q21118 | ROS::TCPROS.Header.deserialize | train | def deserialize(data)
while data.length > 0
len, data = data.unpack('Va*')
msg = data[0..(len-1)]
equal_position = msg.index('=')
key = msg[0..(equal_position-1)]
| ruby | {
"resource": ""
} |
q21119 | ROS::TCPROS.Header.serialize | train | def serialize(buff)
serialized_data = ''
@data.each_pair do |key, value|
data_str = key + '=' + value
serialized_data = serialized_data + [data_str.length, data_str].pack('Va*')
end
| ruby | {
"resource": ""
} |
q21120 | ROS.MasterProxy.unregister_service | train | def unregister_service(service, service_api)
code, message, val = @proxy.unregisterService(@caller_id,
service,
service_api)
if code == 1
| ruby | {
"resource": ""
} |
q21121 | ROS.MasterProxy.register_subscriber | train | def register_subscriber(topic, topic_type)
code, message,val = @proxy.registerSubscriber(@caller_id,
topic,
topic_type,
| ruby | {
"resource": ""
} |
q21122 | ROS.MasterProxy.unregister_subscriber | train | def unregister_subscriber(topic)
code, message,val = @proxy.unregisterSubscriber(@caller_id,
topic,
@slave_uri)
if code == 1
| ruby | {
"resource": ""
} |
q21123 | ROS.MasterProxy.register_publisher | train | def register_publisher(topic, topic_type)
code, message, uris = @proxy.registerPublisher(@caller_id,
topic,
topic_type,
| ruby | {
"resource": ""
} |
q21124 | ROS.MasterProxy.unregister_publisher | train | def unregister_publisher(topic)
code, message, val = @proxy.unregisterPublisher(@caller_id,
topic,
@slave_uri)
if code == 1
| ruby | {
"resource": ""
} |
q21125 | ROS.MasterProxy.subscribe_param | train | def subscribe_param(key)
code, message, uri = @proxy.subscribeParam(@caller_id, @slave_uri, key)
if code == 1
| ruby | {
"resource": ""
} |
q21126 | ROS.MasterProxy.unsubscribe_param | train | def unsubscribe_param(key)
code, message, uri = @proxy.unsubscribeParam(@caller_id, @slave_uri, key)
if code == 1
| ruby | {
"resource": ""
} |
q21127 | ROS.MasterProxy.get_published_topics | train | def get_published_topics(subgraph='')
code, message, topics = @proxy.getPublishedTopics(@caller_id, subgraph)
if code == 1
| ruby | {
"resource": ""
} |
q21128 | ROS.MasterProxy.lookup_service | train | def lookup_service(service)
code, message, uri = @proxy.lookupService(@caller_id, service)
if code | ruby | {
"resource": ""
} |
q21129 | ROS.Node.get_param | train | def get_param(key, default=nil)
key = expand_local_name(@node_name, key)
param = @parameter.get_param(key)
if param
| ruby | {
"resource": ""
} |
q21130 | ROS.Node.advertise | train | def advertise(topic_name, topic_type, options={})
if options[:no_resolve]
name = topic_name
else
name = resolve_name(topic_name)
end
publisher = Publisher.new(@node_name,
name,
topic_type,
| ruby | {
"resource": ""
} |
q21131 | ROS.Node.advertise_service | train | def advertise_service(service_name, service_type, &callback)
server = ::ROS::ServiceServer.new(@node_name,
resolve_name(service_name),
service_type,
| ruby | {
"resource": ""
} |
q21132 | ROS.Node.subscribe | train | def subscribe(topic_name, topic_type, &callback)
sub = Subscriber.new(@node_name,
resolve_name(topic_name),
topic_type,
| ruby | {
"resource": ""
} |
q21133 | ROS.Node.subscribe_parameter | train | def subscribe_parameter(param, &callback)
sub = ParameterSubscriber.new(param, | ruby | {
"resource": ""
} |
q21134 | ROS.Node.convert_if_needed | train | def convert_if_needed(value) #:nodoc:
if value =~ /^[+-]?\d+\.?\d*$/ # float
value = value.to_f
elsif value =~ /^[+-]?\d+$/ # int | ruby | {
"resource": ""
} |
q21135 | ROS.Node.parse_args | train | def parse_args(args) #:nodoc:
remapping = {}
for arg in args
splited = arg.split(':=')
if splited.length == 2
key, value = splited
if key == '__name'
@node_name = resolve_name(value)
elsif key == '__ip'
@host = value
elsif key =... | ruby | {
"resource": ""
} |
q21136 | ROS.Subscriber.add_connection | train | def add_connection(uri) #:nodoc:
publisher = SlaveProxy.new(@caller_id, uri)
begin
protocol, host, port = publisher.request_topic(@topic_name, [["TCPROS"]])
if protocol == "TCPROS"
connection = TCPROS::Client.new(host, port, @caller_id, @topic_name, @topic_type, uri, @tcp_no_delay)... | ruby | {
"resource": ""
} |
q21137 | ROS.Subscriber.get_connection_info | train | def get_connection_info
info = []
@connections.each do |connection|
| ruby | {
"resource": ""
} |
q21138 | Dradis::Plugins::Projects::Export::V1.Template.user_email_for_activity | train | def user_email_for_activity(activity)
return activity.user if activity.user.is_a?(String)
@user_emails ||= begin
User.select([:id, :email]).all.each_with_object({}) do |user, hash|
| ruby | {
"resource": ""
} |
q21139 | Workable.Client.create_job_candidate | train | def create_job_candidate(candidate, shortcode, stage_slug = nil)
shortcode = "#{shortcode}/#{stage_slug}" if stage_slug
response = post_request("jobs/#{shortcode}/candidates") do |request|
| ruby | {
"resource": ""
} |
q21140 | Workable.Client.create_comment | train | def create_comment(candidate_id, member_id, comment_text, policy = [], attachment = nil)
comment = { body: comment_text, policy: policy, attachment: attachment }
| ruby | {
"resource": ""
} |
q21141 | Workable.Client.disqualify | train | def disqualify(candidate_id, member_id, reason = nil)
post_request("candidates/#{candidate_id}/disqualify") do |request|
| ruby | {
"resource": ""
} |
q21142 | Workable.Client.revert | train | def revert(candidate_id, member_id)
post_request("candidates/#{candidate_id}/revert") do |request|
| ruby | {
"resource": ""
} |
q21143 | Workable.Client.copy | train | def copy(candidate_id, member_id, shortcode, stage = nil)
body = {
member_id: member_id,
target_job_shortcode: shortcode,
target_stage: stage
}
| ruby | {
"resource": ""
} |
q21144 | Workable.Client.move | train | def move(candidate_id, member_id, stage)
post_request("candidates/#{candidate_id}/move") do |request|
| ruby | {
"resource": ""
} |
q21145 | Workable.Client.create_rating | train | def create_rating(candidate_id, member_id, comment, score)
body = {
member_id: member_id,
comment: comment,
score: score
} | ruby | {
"resource": ""
} |
q21146 | Workable.Client.get_request | train | def get_request(url, params = {})
params = URI.encode_www_form(params.keep_if { |k, v| k && v })
full_url = params.empty? ? url : [url, | ruby | {
"resource": ""
} |
q21147 | Workable.Client.post_request | train | def post_request(url)
do_request(url, Net::HTTP::Post) do |request|
| ruby | {
"resource": ""
} |
q21148 | Workable.Client.do_request | train | def do_request(url, type, &_block)
uri = URI.parse("#{api_url}/#{url}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = | ruby | {
"resource": ""
} |
q21149 | Workable.Client.parse! | train | def parse!(response)
case response.code.to_i
when 204, 205
nil
when 200...300
JSON.parse(response.body) if !response.body.to_s.empty?
when 401
fail Errors::NotAuthorized, JSON.parse(response.body)['error']
when 404
fail Errors::NotFound, JSON.parse(response.... | ruby | {
"resource": ""
} |
q21150 | Teamlab.Files.create_txt_in_my_docs | train | def create_txt_in_my_docs(title, content)
@request.post(%w[@my text], title: | ruby | {
"resource": ""
} |
q21151 | Workable.Transformation.apply | train | def apply(mapping, data)
transformation = @mappings[mapping]
return data unless transformation
case data
when nil
data
when Array
data.map { | ruby | {
"resource": ""
} |
q21152 | Dradis::Plugins::Projects::Export.Template.export | train | def export(args={})
builder = Builder::XmlMarkup.new
builder.instruct!
result = builder.tag!('dradis-template', version: version) do |template_builder|
build_nodes(template_builder)
build_issues(template_builder)
build_methodologies(template_builder) | ruby | {
"resource": ""
} |
q21153 | DisqusApi.Response.each_resource | train | def each_resource(&block)
Enumerator.new do |result|
each_page { |resources| resources.each { | ruby | {
"resource": ""
} |
q21154 | DisqusApi.Response.each_page | train | def each_page(&block)
Enumerator.new do |result|
next_response = self
while next_response
result << next_response.body.to_a
| ruby | {
"resource": ""
} |
q21155 | DisqusApi.Request.perform | train | def perform(arguments = {})
case type.to_sym
when :post, :get
api.public_send(type, path, @arguments.merge(arguments))
else
raise | ruby | {
"resource": ""
} |
q21156 | EnumHelp.I18n.enum | train | def enum( definitions )
super( definitions )
definitions.each do |name, _|
Helper.define_attr_i18n_method(self, name)
| ruby | {
"resource": ""
} |
q21157 | Cistern::Attributes.InstanceMethods.requires | train | def requires(*args)
missing, required = missing_attributes(args)
if missing.length == 1
fail(ArgumentError, "#{missing.keys.first} is required for this operation")
elsif missing.any?
| ruby | {
"resource": ""
} |
q21158 | Cistern::Attributes.InstanceMethods.requires_one | train | def requires_one(*args)
missing, required = missing_attributes(args)
if missing.length == args.length
fail(ArgumentError, | ruby | {
"resource": ""
} |
q21159 | JiraHelper.Issue.fetch_issues | train | def fetch_issues(jql, suppress_exceptions = false)
client.Issue.jql(jql)
rescue StandardError => e
| ruby | {
"resource": ""
} |
q21160 | Diffbot.Request.build_request | train | def build_request(method, query_params={})
query = { token: token }.merge(query_params)
request = { query: query, method: method, headers: {}, | ruby | {
"resource": ""
} |
q21161 | SSRFProxy.Server.port_open? | train | def port_open?(ip, port, seconds = 10)
Timeout.timeout(seconds) do
TCPSocket.new(ip, port).close
true
end
| ruby | {
"resource": ""
} |
q21162 | SSRFProxy.Server.handle_connection | train | def handle_connection(socket)
start_time = Time.now
_, port, host = socket.peeraddr
logger.debug("Client #{host}:#{port} connected")
request = socket.read
logger.debug("Received client request (#{request.length} bytes):\n" \
"#{request}")
response = nil
if r... | ruby | {
"resource": ""
} |
q21163 | SSRFProxy.HTTP.encode_ip | train | def encode_ip(url, mode)
return if url.nil?
new_host = nil
host = URI.parse(url.to_s.split('?').first).host.to_s
begin
ip = IPAddress::IPv4.new(host)
rescue
logger.warn("Could not parse requested host as IPv4 address: #{host}")
return url
end
case mode
... | ruby | {
"resource": ""
} |
q21164 | SSRFProxy.HTTP.run_rules | train | def run_rules(url, rules)
str = url.to_s
return str if rules.nil?
rules.each do |rule|
case rule
when 'noproto'
str = str.gsub(%r{^https?://}, '')
when 'nossl', 'http'
str = str.gsub(%r{^https://}, 'http://')
when 'ssl', 'https'
str = str.g... | ruby | {
"resource": ""
} |
q21165 | SSRFProxy.HTTP.guess_mime | train | def guess_mime(ext)
content_types = WEBrick::HTTPUtils::DefaultMimeTypes
common_content_types = { 'ico' => 'image/x-icon' | ruby | {
"resource": ""
} |
q21166 | SSRFProxy.HTTP.sniff_mime | train | def sniff_mime(content)
m = MimeMagic.by_magic(content)
return if m.nil?
# Overwrite incorrect mime types
| ruby | {
"resource": ""
} |
q21167 | Blocks.AbstractRenderer.without_haml_interference | train | def without_haml_interference(&block)
if defined?(::Haml) && view.instance_variables.include?(:@haml_buffer)
haml_buffer = view.instance_variable_get(:@haml_buffer)
if haml_buffer
was_active = haml_buffer.active?
haml_buffer.active = false
else
haml_buffer = H... | ruby | {
"resource": ""
} |
q21168 | Riot.ContextHelpers.setup | train | def setup(premium=false, &definition)
setup = Setup.new(&definition) | ruby | {
"resource": ""
} |
q21169 | Rfd.Controller.move_cursor | train | def move_cursor(row = nil)
if row
if (prev_item = items[current_row])
main.draw_item prev_item
end
page = row / max_items
switch_page page if page != current_page
main.activate_pane row / maxy
@current_row = row
else
| ruby | {
"resource": ""
} |
q21170 | Rfd.Controller.cd | train | def cd(dir = '~', pushd: true)
dir = load_item path: expand_path(dir) unless dir.is_a? Item
unless dir.zip?
Dir.chdir dir
@current_zip = nil
else
@current_zip = dir
end
@dir_history << current_dir | ruby | {
"resource": ""
} |
q21171 | Rfd.Controller.ls | train | def ls
fetch_items_from_filesystem_or_zip
sort_items_according_to_current_direction
@current_page ||= 0
draw_items
move_cursor (current_row ? | ruby | {
"resource": ""
} |
q21172 | Rfd.Controller.chmod | train | def chmod(mode = nil)
return unless mode
begin
Integer mode
mode = Integer mode.size == 3 ? "0#{mode}" : mode
rescue ArgumentError
| ruby | {
"resource": ""
} |
q21173 | Rfd.Controller.chown | train | def chown(user_and_group)
return unless user_and_group
user, group = user_and_group.split(':').map {|s| s == '' ? nil : s}
| ruby | {
"resource": ""
} |
q21174 | Rfd.Controller.fetch_items_from_filesystem_or_zip | train | def fetch_items_from_filesystem_or_zip
unless in_zip?
@items = Dir.foreach(current_dir).map {|fn|
load_item dir: current_dir, name: fn
}.to_a.partition {|i| %w(. ..).include? i.name}.flatten
else
@items = [load_item(dir: current_dir, name: '.', stat: File.stat(current_dir))... | ruby | {
"resource": ""
} |
q21175 | Rfd.Controller.find | train | def find(str)
index = items.index {|i| i.index > current_row && i.name.start_with?(str)} | ruby | {
"resource": ""
} |
q21176 | Rfd.Controller.find_reverse | train | def find_reverse(str)
index = items.reverse.index {|i| i.index < current_row && i.name.start_with?(str)} | ruby | {
"resource": ""
} |
q21177 | Rfd.Controller.draw_items | train | def draw_items
main.newpad items
@displayed_items = items[current_page * max_items, max_items]
| ruby | {
"resource": ""
} |
q21178 | Rfd.Controller.sort_items_according_to_current_direction | train | def sort_items_according_to_current_direction
case @direction
when nil
@items = items.shift(2) + items.partition(&:directory?).flat_map(&:sort)
when 'r'
@items = items.shift(2) + items.partition(&:directory?).flat_map {|arr| arr.sort.reverse}
when 'S', 's'
@items = items.... | ruby | {
"resource": ""
} |
q21179 | Rfd.Controller.grep | train | def grep(pattern = '.*')
regexp = Regexp.new(pattern)
fetch_items_from_filesystem_or_zip
@items = items.shift(2) + items.select {|i| i.name =~ regexp}
| ruby | {
"resource": ""
} |
q21180 | Rfd.Controller.cp | train | def cp(dest)
unless in_zip?
src = (m = marked_items).any? ? m.map(&:path) : current_item
FileUtils.cp_r src, expand_path(dest)
else
raise 'cping multiple items in .zip is not supported.' | ruby | {
"resource": ""
} |
q21181 | Rfd.Controller.mv | train | def mv(dest)
unless in_zip?
src = (m = marked_items).any? ? m.map(&:path) : current_item
FileUtils.mv src, expand_path(dest)
else
raise 'mving multiple | ruby | {
"resource": ""
} |
q21182 | Rfd.Controller.rename | train | def rename(pattern)
from, to = pattern.sub(/^\//, '').sub(/\/$/, '').split '/'
if to.nil?
from, to = current_item.name, from
else
from = Regexp.new from
end
unless in_zip?
selected_items.each do |item|
name = item.name.gsub from, to
FileUtils.mv ... | ruby | {
"resource": ""
} |
q21183 | Rfd.Controller.trash | train | def trash
unless in_zip?
if osx?
FileUtils.mv selected_items.map(&:path), File.expand_path('~/.Trash/')
else
#TODO support other OS
FileUtils.rm_rf selected_items.map(&:path)
end
else
return unless ask %Q[Trashing zip entries is not supported. Ac... | ruby | {
"resource": ""
} |
q21184 | Rfd.Controller.delete | train | def delete
unless in_zip?
FileUtils.rm_rf selected_items.map(&:path)
else
Zip::File.open(current_zip) do |zip|
zip.select {|e| selected_items.map(&:name).include? e.to_s}.each do |entry|
if entry.name_is_directory?
zip.dir.delete entry.to_s
| ruby | {
"resource": ""
} |
q21185 | Rfd.Controller.mkdir | train | def mkdir(dir)
unless in_zip?
FileUtils.mkdir_p current_dir.join(dir)
else
Zip::File.open(current_zip) do |zip| | ruby | {
"resource": ""
} |
q21186 | Rfd.Controller.touch | train | def touch(filename)
unless in_zip?
FileUtils.touch current_dir.join(filename)
else
Zip::File.open(current_zip) do |zip|
| ruby | {
"resource": ""
} |
q21187 | Rfd.Controller.zip | train | def zip(zipfile_name)
return unless zipfile_name
zipfile_name += '.zip' unless zipfile_name.end_with? '.zip'
Zip::File.open(zipfile_name, Zip::File::CREATE) do |zipfile|
selected_items.each do |item|
next if item.symlink?
if item.directory?
| ruby | {
"resource": ""
} |
q21188 | Rfd.Controller.unarchive | train | def unarchive
unless in_zip?
zips, gzs = selected_items.partition(&:zip?).tap {|z, others| break [z, *others.partition(&:gz?)]}
zips.each do |item|
FileUtils.mkdir_p current_dir.join(item.basename)
Zip::File.open(item) do |zip|
zip.each do |entry|
File... | ruby | {
"resource": ""
} |
q21189 | Rfd.Controller.switch_page | train | def switch_page(page)
main.display (@current_page = page)
@displayed_items = items[current_page * max_items, max_items]
| ruby | {
"resource": ""
} |
q21190 | Rfd.Controller.draw_marked_items | train | def draw_marked_items
items = marked_items
header_r.draw_marked_items | ruby | {
"resource": ""
} |
q21191 | Rfd.Controller.draw_total_items | train | def draw_total_items
header_r.draw_total_items | ruby | {
"resource": ""
} |
q21192 | Rfd.Controller.process_command_line | train | def process_command_line(preset_command: nil)
prompt = preset_command ? ":#{preset_command} " : ':'
command_line.set_prompt prompt
cmd, *args = command_line.get_command(prompt: prompt).split(' ')
if cmd && !cmd.empty? && respond_to?(cmd)
| ruby | {
"resource": ""
} |
q21193 | Rfd.Controller.process_shell_command | train | def process_shell_command
command_line.set_prompt ':!'
cmd = command_line.get_command(prompt: ':!')[1..-1]
| ruby | {
"resource": ""
} |
q21194 | Rfd.Controller.ask | train | def ask(prompt = '(y/n)')
command_line.set_prompt prompt
command_line.refresh
while (c = Curses.getch)
next unless [?N, ?Y, ?n, ?y, 3, 27] .include? c # N, Y, n, y, | ruby | {
"resource": ""
} |
q21195 | Rfd.Controller.edit | train | def edit
execute_external_command do
editor = ENV['EDITOR'] || 'vim'
unless in_zip?
system %Q[#{editor} "#{current_item.path}"]
else
begin
tmpdir, tmpfile_name = nil
Zip::File.open(current_zip) do |zip|
tmpdir = Dir.mktmpdir
... | ruby | {
"resource": ""
} |
q21196 | Rfd.Controller.view | train | def view
pager = ENV['PAGER'] || 'less'
execute_external_command do
unless in_zip?
system %Q[#{pager} "#{current_item.path}"]
else
begin
tmpdir, tmpfile_name = nil
Zip::File.open(current_zip) do |zip|
tmpdir = Dir.mktmpdir
... | ruby | {
"resource": ""
} |
q21197 | Riot.Assertion.run | train | def run(situation)
@expectings << situation.evaluate(&@expectation_block) if @expectation_block
actual = situation.evaluate(&definition)
| ruby | {
"resource": ""
} |
q21198 | Riot.IOReporter.format_error | train | def format_error(e)
format = [" #{e.class.name} occurred", "#{e.to_s}"]
filter_backtrace(e.backtrace) { |line| | ruby | {
"resource": ""
} |
q21199 | Rfd.Commands.O | train | def O
dir = current_item.directory? ? current_item.path : current_dir.path
| ruby | {
"resource": ""
} |
Subsets and Splits
SQL Console for CoIR-Retrieval/CodeSearchNet-ccr-ruby-queries-corpus
Retrieves a large number of entries in the 'ruby' language, providing basic information but limited analytical value.