_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5200 | Biopsy.Target.method_missing | train | def method_missing(method, *args, &block)
const_methods = @constructor.class.instance_methods(false)
if const_methods.include? method
return | ruby | {
"resource": ""
} |
q5201 | Biopsy.Target.respond_to? | train | def respond_to?(method, *args, &block)
const_methods = @constructor.class.instance_methods(false) | ruby | {
"resource": ""
} |
q5202 | BadFruit.Base.get_movie_info | train | def get_movie_info(movie_id, action)
url = nil
case action
when "details"
url = "#{MOVIE_DETAIL_BASE_URL}/#{movie_id}.json?apikey=#{@api_key}"
when "reviews"
url = "#{MOVIE_DETAIL_BASE_URL}/#{movie_id}/reviews.json?apikey=#{@api_key}"
| ruby | {
"resource": ""
} |
q5203 | BadFruit.Base.get_lists_action | train | def get_lists_action(action)
url = nil
case action
when "new_releases"
url = "#{LISTS_DETAIL_BASE_URL}/dvds/new_releases.json?apikey=#{@api_key}"
when "opening"
url = "#{LISTS_DETAIL_BASE_URL}/movies/opening.json?apikey=#{@api_key}"
when "upcoming"
url = "#{LISTS_DE... | ruby | {
"resource": ""
} |
q5204 | BadFruit.Base.parse_movies_array | train | def parse_movies_array(hash)
moviesArray = Array.new
hash["movies"].each do |movie|
| ruby | {
"resource": ""
} |
q5205 | BadFruit.Base.parse_actors_array | train | def parse_actors_array(hash)
actorsArray = Array.new
hash["cast"].each do |actor|
| ruby | {
"resource": ""
} |
q5206 | BadFruit.Base.get | train | def get(url)
data = nil
resp = HTTParty.get(url)
if resp.code | ruby | {
"resource": ""
} |
q5207 | Chatrix.Client.sync! | train | def sync!
events = @matrix.sync since: @since
process_sync | ruby | {
"resource": ""
} |
q5208 | Chatrix.Client.process_sync | train | def process_sync(events)
return unless events.is_a? Hash
@since = events['next_batch']
| ruby | {
"resource": ""
} |
q5209 | Auth.ApplicationHelper.get_signed_in_scope | train | def get_signed_in_scope
if signed_in?
Devise.mappings.keys.each do |res|
l = send "#{res.to_s}_signed_in?"
if send "#{res.to_s}_signed_in?"
| ruby | {
"resource": ""
} |
q5210 | Auth.ApplicationHelper.resource_in_navbar? | train | def resource_in_navbar?(resource)
return false unless resource
return | ruby | {
"resource": ""
} |
q5211 | Rubikon.HasArguments.<< | train | def <<(arg)
raise ExtraArgumentError.new(@name) unless more_args?
if @arg_names.size > @args.size
name = @arg_names[@args.size]
if @max_arg_count == -1 && @arg_names.size == @args.size + 1
@args[name] = [arg]
else
| ruby | {
"resource": ""
} |
q5212 | Rubikon.HasArguments.check_args | train | def check_args
raise MissingArgumentError.new(@name) unless args_full?
unless @arg_values.empty?
@args.each do |name, arg|
if @arg_values.key? name
arg = [arg] unless arg.is_a? Array
arg.each do |a|
| ruby | {
"resource": ""
} |
q5213 | Rubikon.HasArguments.method_missing | train | def method_missing(name, *args, &block)
if args.empty? && !block_given? && @arg_names.include?(name)
| ruby | {
"resource": ""
} |
q5214 | Pubsubstub.Subscription.fetch_scrollback | train | def fetch_scrollback(last_event_id)
event_sent = false
if last_event_id
channels.each do |channel|
channel.scrollback(since: last_event_id).each do | ruby | {
"resource": ""
} |
q5215 | GosuEnhanced.Region.contains? | train | def contains?(col, row = nil)
return contains_point?(col) if col.respond_to? :x
col.between?(left, | ruby | {
"resource": ""
} |
q5216 | GosuEnhanced.Region.draw | train | def draw(surface, z_order, colour)
su | ruby | {
"resource": ""
} |
q5217 | GosuEnhanced.Region.contains_point? | train | def contains_point?(pt)
pt.x.between?(left, left + width - 1) &&
| ruby | {
"resource": ""
} |
q5218 | Biopsy.Experiment.select_algorithm | train | def select_algorithm
return if algorithm
max = Settings.instance.sweep_cutoff
n = @target.count_parameter_permutations
if n < max
| ruby | {
"resource": ""
} |
q5219 | Biopsy.Experiment.run | train | def run
start_time = Time.now
in_progress = true
@algorithm.setup @start
@current_params = @start
max_scores = @target.count_parameter_permutations
while in_progress
run_iteration
# update the best result
best = @best
@best = @algorithm.best
pt... | ruby | {
"resource": ""
} |
q5220 | Biopsy.Experiment.create_tempdir | train | def create_tempdir
token = loop do
# generate random dirnames until we find one that
# doesn't exist
test_token = SecureRandom.hex
| ruby | {
"resource": ""
} |
q5221 | Biopsy.Experiment.set_id | train | def set_id id
@id = id
if @id.nil?
t = Time.now
parts = | ruby | {
"resource": ""
} |
q5222 | Racket.Registry.register | train | def register(key, proc = nil, &block)
Helper.register(obj: self, key: | ruby | {
"resource": ""
} |
q5223 | Racket.Registry.register_singleton | train | def register_singleton(key, proc = nil, &block)
Helper.register_singleton(obj: self, | ruby | {
"resource": ""
} |
q5224 | DataMapper.Model.generate | train | def generate(name = default_fauxture_name, attributes = {})
name, attributes = default_fauxture_name, name if | ruby | {
"resource": ""
} |
q5225 | DataMapper.Model.make | train | def make(name = default_fauxture_name, attributes = {})
name, attributes = default_fauxture_name, name if | ruby | {
"resource": ""
} |
q5226 | DeploYML.Project.environment | train | def environment(name=:production)
name = name.to_sym
unless @environments[name]
raise(UnknownEnvironment,"unknown | ruby | {
"resource": ""
} |
q5227 | DeploYML.Project.load_configuration | train | def load_configuration(path)
config = YAML.load_file(path)
unless config.kind_of?(Hash)
raise(InvalidConfig,"DeploYML | ruby | {
"resource": ""
} |
q5228 | DeploYML.Project.load_environments! | train | def load_environments!
base_config = infer_configuration
if File.file?(@config_file)
base_config.merge!(load_configuration(@config_file))
end
@environments = {}
if File.directory?(@environments_dir)
| ruby | {
"resource": ""
} |
q5229 | Cogbot.Bot.start | train | def start
# prepare config
config = {}
begin
config = YAML::load_file(CONFIG_FILE)
rescue Exception => e
load 'lib/cogbot/setup.rb'
config['main'] = Cogbot::Setup.init
end
# prepare daemon
Daemons.daemonize(
:app_name => 'cogbot',
:dir_... | ruby | {
"resource": ""
} |
q5230 | Cogbot.Bot.stop | train | def stop
pid_file = File.join(CONFIG_DIR, 'cogbot.pid')
pid = | ruby | {
"resource": ""
} |
q5231 | Polisher.VersionedDependencies.dependency_versions | train | def dependency_versions(args = {}, &bl)
versions = {}
args = {:recursive => true, :dev_deps => true, :versions => versions}.merge(args)
deps.each do |dep|
| ruby | {
"resource": ""
} |
q5232 | Polisher.VersionedDependencies.dependency_tree | train | def dependency_tree(args = {}, &bl)
dependencies = {}
args = {:recursive => true,
:dev_deps => true,
:matching => :latest,
:dependencies => dependencies}.merge(args)
process = []
| ruby | {
"resource": ""
} |
q5233 | Polisher.VersionedDependencies.missing_dependencies | train | def missing_dependencies
missing = []
dependency_versions(:recursive => false).each do |pkg, target_versions|
found = false
target_versions.each do |_target, versions|
dependency = dependency_for(pkg)
| ruby | {
"resource": ""
} |
q5234 | Polisher.VersionedDependencies.dependency_states | train | def dependency_states
states = {}
deps.each do |dep|
gem = Polisher::Gem.new :name => dep.name
| ruby | {
"resource": ""
} |
q5235 | Push0r.Queue.add | train | def add(message)
@services.each do |service|
if service.can_send?(message)
if @queued_messages[service].nil?
@queued_messages[service] = []
end
| ruby | {
"resource": ""
} |
q5236 | Push0r.Queue.flush | train | def flush
failed_messages = []
new_token_messages = []
@queued_messages.each do |service, messages|
service.init_push
messages.each do |message|
service.send(message)
end
(failed, new_token) = service.end_push
| ruby | {
"resource": ""
} |
q5237 | DeploYML.Configuration.normalize_hash | train | def normalize_hash(hash)
new_hash = {}
hash.each do |key,value|
new_hash[key.to_sym] | ruby | {
"resource": ""
} |
q5238 | DeploYML.Configuration.normalize | train | def normalize(value)
case value
when Hash
normalize_hash(value)
| ruby | {
"resource": ""
} |
q5239 | DeploYML.Configuration.parse_server | train | def parse_server(server)
name = nil
options = {}
case server
when Symbol, String
name = server.to_sym
when Hash
unless server.has_key?(:name)
raise(MissingOption,"the 'server' option must contain a 'name' option for which server to use",caller)
end
... | ruby | {
"resource": ""
} |
q5240 | DeploYML.Configuration.parse_address | train | def parse_address(address)
case address
when Hash
Addressable::URI.new(address)
when String
Addressable::URI.parse(address)
| ruby | {
"resource": ""
} |
q5241 | DeploYML.Configuration.parse_dest | train | def parse_dest(dest)
case dest
when Array
dest.map { |address| parse_address(address) }
| ruby | {
"resource": ""
} |
q5242 | DeploYML.Configuration.parse_commands | train | def parse_commands(command)
case command
when Array
command.map { |line| line.to_s }
when String
command.enum_for(:each_line).map { |line| line.chomp }
| ruby | {
"resource": ""
} |
q5243 | BadFruit.Movie.reviews | train | def reviews
data = JSON.parse(@badfruit.get_movie_info(@id, "reviews"))
reviews = Array.new
data["reviews"].each do |review|
| ruby | {
"resource": ""
} |
q5244 | ConfigCurator.Collection.units | train | def units
@units ||= {}.tap do |u|
UNIT_TYPES.each do |type|
k = type.to_s.pluralize.to_sym
u[k] = []
next unless manifest
next if manifest[k].nil?
| ruby | {
"resource": ""
} |
q5245 | ConfigCurator.Collection.install | train | def install
return false unless install? quiet: !(logger.level == Logger::DEBUG)
UNIT_TYPES.each do |type|
units[type.to_s.pluralize.to_sym].each do |unit|
| ruby | {
"resource": ""
} |
q5246 | ConfigCurator.Collection.install? | train | def install?(quiet: false)
result = true
UNIT_TYPES.each do |type|
units[type.to_s.pluralize.to_sym].each do |unit|
| ruby | {
"resource": ""
} |
q5247 | ConfigCurator.Collection.create_unit | train | def create_unit(type, attributes: {})
"#{self.class.name.split('::').first}::#{type.to_s.camelize}".constantize
.new(options: unit_options, logger: logger).tap do |unit|
{src: :source, dst: :destination}.each do |k, v|
unit.send "#{v}=".to_sym, attributes[k] unless attributes[k].nil?
... | ruby | {
"resource": ""
} |
q5248 | ConfigCurator.Collection.unit_options | train | def unit_options
options = {}
return options unless manifest
%i(root package_tool).each do |k|
| ruby | {
"resource": ""
} |
q5249 | ConfigCurator.Collection.install_unit | train | def install_unit(unit, type, quiet = false)
success = unit.install
logger.info do
"Installed #{type_name(type)}: #{unit.source} => #{unit.destination_path}"
| ruby | {
"resource": ""
} |
q5250 | ConfigCurator.Collection.install_unit? | train | def install_unit?(unit, type, quiet = false)
unit.install?
logger.info do
"Testing install for #{type_name(type)}:" \
" #{unit.source} => #{unit.destination_path}"
end unless quiet
| ruby | {
"resource": ""
} |
q5251 | Bcome::Registry::Command.Shortcut.execute | train | def execute(node, arguments) ## We'll add in arguments later
if run_as_pseudo_tty?
node.pseudo_tty command
else
node.run command | ruby | {
"resource": ""
} |
q5252 | Assemblotron.Controller.process_options | train | def process_options options
options = options.clone
[:left, :right].each do |key|
if options.key?(key) && !(options[key].nil?)
options[key] | ruby | {
"resource": ""
} |
q5253 | Assemblotron.Controller.run | train | def run
if @options[:list_assemblers]
puts @assemblerman.list_assemblers
return
elsif @options[:install_assemblers]
@assemblerman.install_assemblers(@options[:install_assemblers])
return
end
if (@options[:left].nil? || @options[:right].nil?)
logger.error ... | ruby | {
"resource": ""
} |
q5254 | Assemblotron.Controller.init_settings | train | def init_settings
s = Biopsy::Settings.instance
s.set_defaults
libdir = File.dirname(__FILE__)
| ruby | {
"resource": ""
} |
q5255 | Assemblotron.Controller.write_metadata | train | def write_metadata res
File.open(@options[:output_parameters], 'wb') do |f|
| ruby | {
"resource": ""
} |
q5256 | Assemblotron.Controller.subsample_input | train | def subsample_input
if @options[:skip_subsample]
logger.info "Skipping subsample step (--skip-subsample is on)"
@options[:left_subset] = @options[:left]
@options[:right_subset] = @options[:right]
return
end
logger.info "Subsampling reads"
seed = @options[:seed]... | ruby | {
"resource": ""
} |
q5257 | Assemblotron.Controller.merge_assemblies | train | def merge_assemblies res
l = @options[:left]
r = @options[:right]
transfuse = Transfuse::Transfuse.new(@options[:threads], false)
assemblies = res.each_value.map { |assembler| assember[:final] }
| ruby | {
"resource": ""
} |
q5258 | Biopsy.Settings.all_settings | train | def all_settings
settings = {}
instance_variables.each do |var|
key = var[1..-1]
| ruby | {
"resource": ""
} |
q5259 | Gosu.Window.draw_rectangle | train | def draw_rectangle(point, size, z_index, colour)
left = point.x
top = point.y
width = size.width
height = size.height
draw_quad(
left, top, colour,
left + width, top, colour,
| ruby | {
"resource": ""
} |
q5260 | Gosu.Window.draw_simple_line | train | def draw_simple_line(p1, p2, z_index, colour)
| ruby | {
"resource": ""
} |
q5261 | Gosu.Font.centred_in | train | def centred_in(text, rect)
size = measure(text)
Point((rect.width - size.width) / | ruby | {
"resource": ""
} |
q5262 | BrB.Request.new_brb_out_request | train | def new_brb_out_request(meth, *args, &blck)
Thread.current[:brb_nb_out] ||= 0
Thread.current[:brb_nb_out] += 1
raise BrBCallbackWithBlockingMethodException.new if is_brb_request_blocking?(meth) and block_given?
block = (is_brb_request_blocking?(meth) or block_given?) ? Thread.current.to_... | ruby | {
"resource": ""
} |
q5263 | BrB.Request.new_brb_in_request | train | def new_brb_in_request(meth, *args)
if is_brb_request_blocking?(meth)
m = meth.to_s
m = m[0, m.size - 6].to_sym
idrequest = args.pop
thread = args.pop
begin
r = ((args.size > 0) ? @object.send(m, *args) : @object.send(m))
brb_send([ReturnCo... | ruby | {
"resource": ""
} |
q5264 | Polisher.GemDiff.diff | train | def diff(other)
require_dep! 'awesome_spawn'
require_cmd! diff_cmd
out = nil
begin
this_dir = unpack
other_dir = if other.is_a?(Polisher::Gem)
other.unpack
elsif other.is_a?(Polisher::Git::Repo)
other.path
... | ruby | {
"resource": ""
} |
q5265 | Passbook.RegistrationsController.push_token | train | def push_token
return params[:pushToken] if params.include?(:pushToken)
if request && request.body
request.body.rewind
json_body = JSON.parse(request.body.read)
| ruby | {
"resource": ""
} |
q5266 | Siba.Generator.generate | train | def generate
siba_file.run_this do
file_path = @name.gsub /\.yml$/, ""
file_path += ".yml"
file_path = siba_file.file_expand_path file_path
if siba_file.file_file?(file_path) || siba_file.file_directory?(file_path)
raise Siba::Error, "Options file already exists: #{file_p... | ruby | {
"resource": ""
} |
q5267 | Sanscript.Transliterate.add_brahmic_scheme | train | def add_brahmic_scheme(name, scheme)
name = name.to_sym
scheme = scheme.deep_dup
| ruby | {
"resource": ""
} |
q5268 | Sanscript.Transliterate.add_roman_scheme | train | def add_roman_scheme(name, scheme)
name = name.to_sym
scheme = scheme.deep_dup
scheme[:vowel_marks] = scheme[:vowels][1..-1] unless scheme.key?(:vowel_marks)
@schemes[name] | ruby | {
"resource": ""
} |
q5269 | Sanscript.Transliterate.transliterate | train | def transliterate(data, from, to, **opts)
from = from.to_sym
to = to.to_sym
return data if from == to
raise SchemeNotSupportedError, from unless @schemes.key?(from)
raise SchemeNotSupportedError, to unless @schemes.key?(to)
data = data.to_str.dup
options = @defaults.merge(opts... | ruby | {
"resource": ""
} |
q5270 | DeploYML.LocalShell.run | train | def run(program,*arguments)
program = program.to_s
| ruby | {
"resource": ""
} |
q5271 | ThorSsh.RemoteFile.mkdir_p | train | def mkdir_p(path)
stdout, stderr, _, _ = exec("mkdir -p #{path.inspect}", :with_codes => true)
if stderr =~ | ruby | {
"resource": ""
} |
q5272 | LatoCore.Cell.validate_args | train | def validate_args(args: {}, requested_args: [], default_args: {})
requested_args.each do |requested_arg|
raise "Cell must have #{requested_arg} argument" if args[requested_arg] == nil
end
| ruby | {
"resource": ""
} |
q5273 | ConfigCurator.Utils.command? | train | def command?(command)
MakeMakefile::Logging.instance_variable_set :@logfile, File::NULL
MakeMakefile::Logging.quiet = | ruby | {
"resource": ""
} |
q5274 | ResourcesController.Specification.find_resource | train | def find_resource(controller)
(controller.enclosing_resource | ruby | {
"resource": ""
} |
q5275 | ResourcesController.SingletonSpecification.find_resource | train | def find_resource(controller)
ResourcesController.raise_cant_find_singleton(name, | ruby | {
"resource": ""
} |
q5276 | DeploYML.CLI.find_root | train | def find_root
Pathname.pwd.ascend do |root|
config_dir = root.join(Project::CONFIG_DIR)
if config_dir.directory?
config_file = config_dir.join(Project::CONFIG_FILE)
return root if config_file.file?
environments_dir = config_dir.join(Project::ENVIRONMENTS_DIR)
... | ruby | {
"resource": ""
} |
q5277 | Biopsy.ObjectiveHandler.dimension_reduce | train | def dimension_reduce(results)
# calculate the weighted Euclidean distance from optimal
# d(p, q) = \sqrt{(p_1 - q_1)^2 + (p_2 - q_2)^2+...+(p_n - q_n)^2}
# here the max value is sqrt(n) where n is no. of results,
# min value (optimum) is 0
total = 0
results.each_value do |value|
| ruby | {
"resource": ""
} |
q5278 | GroupMe.Bots.bot_post | train | def bot_post(id, text, options = {})
data = {
:bot_id => id,
:text => text
}
data[:options] | ruby | {
"resource": ""
} |
q5279 | GroupMe.Bots.create_bot | train | def create_bot(name, group_id, options = {})
data = {
| ruby | {
"resource": ""
} |
q5280 | AwsSesNewsletters.NewslettersSender.preview_to | train | def preview_to(recipient)
@newsletter = build_newsletter
mail = | ruby | {
"resource": ""
} |
q5281 | AwsSesNewsletters.NewslettersSender.send_emails | train | def send_emails
mail = build_mail
get_recipients do |recipient|
unless EmailResponse.exists?(email: recipient.email) # bounces & complaints
mail.to = recipient.email | ruby | {
"resource": ""
} |
q5282 | AwsSesNewsletters.NewslettersSender.replace_and_send_mail_safely | train | def replace_and_send_mail_safely(mail, recipient)
html_body = mail.html_part.body.raw_source
do_custom_replacements_for(mail, recipient)
| ruby | {
"resource": ""
} |
q5283 | AwsSesNewsletters.NewslettersSender.build_mail | train | def build_mail
AwsSesNewsletters::MailBuilder.new(
from: newsletter.from,
subject: newsletter.subject,
| ruby | {
"resource": ""
} |
q5284 | Auth::Concerns::Shopping::PaymentConcern.ClassMethods.get_discount_payments | train | def get_discount_payments(cart_id)
discount_payments = Auth.configuration.payment_class.constantize.where(:cart_id | ruby | {
"resource": ""
} |
q5285 | Auth::Concerns::Shopping::PaymentConcern.ClassMethods.get_sum_of_discount_payments | train | def get_sum_of_discount_payments(cart_id)
sum_of_discount_payments = 0
get_discount_payments(cart_id).each do |dp|
| ruby | {
"resource": ""
} |
q5286 | LatoCore.Interface::General.core__read_yaml | train | def core__read_yaml(file_path)
# return nil if file not exist
return unless File.exist?(file_path)
config_file = File.read(file_path)
# return yaml | ruby | {
"resource": ""
} |
q5287 | LatoCore.Interface::General.core__paginate_array | train | def core__paginate_array(array, per_page, page)
start = (page - | ruby | {
"resource": ""
} |
q5288 | LatoCore.Interface::General.core__add_param_to_url | train | def core__add_param_to_url(url, param_name, param_value)
uri = URI(url)
params | ruby | {
"resource": ""
} |
q5289 | Polisher.CheckerLoader.targets | train | def targets
@targets ||= Dir.glob(File.join(target_dir, '*.rb'))
| ruby | {
"resource": ""
} |
q5290 | Polisher.CheckerLoader.load_target | train | def load_target(target)
raise ArgumentError, target unless targets.include?(target)
require "polisher/adaptors/version_checker/#{target}"
tm = | ruby | {
"resource": ""
} |
q5291 | Auth::Concerns::ActivityConcern.ClassMethods.activities_from_to | train | def activities_from_to(query,default_from,default_to)
defaults = {"range" => {"from" => default_from, "to" => default_to}}
query = defaults.deep_merge(query)
##default from and to assigned here.
from = query["range"]["from"].to_i
| ruby | {
"resource": ""
} |
q5292 | Auth::Concerns::ActivityConcern.ClassMethods.activities_fields | train | def activities_fields(query)
defaults = {"only" => Object.const_get(name).fields.keys}
query = defaults.deep_merge(query) | ruby | {
"resource": ""
} |
q5293 | Prometheus.PluginDSL.start | train | def start
if File.exists? CONFIG_PATH
if Config.missing_configurables.size > 0
Prometheus::ConfigCommands.new.invoke :repair
else
| ruby | {
"resource": ""
} |
q5294 | Chatrix.Users.[] | train | def [](id)
return @users[id] if id.start_with? '@'
res = @users.find { |_, u| u.displayname == id } | ruby | {
"resource": ""
} |
q5295 | Chatrix.Users.process_power_levels | train | def process_power_levels(room, data)
data.each do |id, level|
| ruby | {
"resource": ""
} |
q5296 | Chatrix.Users.process_invite | train | def process_invite(room, event)
sender = get_user(event['sender'])
invitee = get_user(event['state_key']) | ruby | {
"resource": ""
} |
q5297 | Chatrix.Users.get_user | train | def get_user(id)
return @users[id] if @users.key? id
| ruby | {
"resource": ""
} |
q5298 | ResourcesController.ClassMethods.nested_in | train | def nested_in(*names, &block)
options = names.extract_options!
raise ArgumentError, "when giving more than one nesting, you may not specify options or a block" if names.length > 1 and (block_given? or options.length > 0)
# convert :polymorphic option to '?'
if options.delete(:polymorphic)
... | ruby | {
"resource": ""
} |
q5299 | ResourcesController.ClassMethods.ensure_sane_wildcard | train | def ensure_sane_wildcard
idx = specifications.length
while (idx -= 1) >= 0
if specifications[idx] == '*'
raise ArgumentError, "Can only specify one wildcard '*' in between resource specifications"
| 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.