_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q6300 | Mutter.Mutterer.unstyle | train | def unstyle msg
styles.map do |_,v|
v[:match]
end.flatten.inject(msg) do |m, | ruby | {
"resource": ""
} |
q6301 | Mutter.Mutterer.write | train | def write str
self.class.stream.tap do |stream|
stream.write str
| ruby | {
"resource": ""
} |
q6302 | Mutter.Mutterer.stylize | train | def stylize string, styles = []
[styles].flatten.inject(string) do |str, style|
style = style.to_sym
if ANSI[:transforms].include? style
| ruby | {
"resource": ""
} |
q6303 | Seiten.Page.parent_of? | train | def parent_of?(child)
page = self
if child
if page.id == child.parent_id
| ruby | {
"resource": ""
} |
q6304 | Seiten.Page.active? | train | def active?(current_page)
if current_page
if id == current_page.id
true
elsif parent_of?(current_page) | ruby | {
"resource": ""
} |
q6305 | Sequel.LoadDataInfile.load_infile_sql | train | def load_infile_sql(path, columns, options={})
replacement = opts[:insert_ignore] ? :ignore : :replace
options = {:update => replacement}.merge(options)
LoadDataInfileExpression.new(path,
| ruby | {
"resource": ""
} |
q6306 | Features.SessionHelpers.sign_in_as | train | def sign_in_as(group)
FactoryGirl.create(:user, umbcusername: 'test_user', group: group)
| ruby | {
"resource": ""
} |
q6307 | Poster.Site.connect | train | def connect uri
Faraday.new(:url => "#{uri.scheme}://#{uri.host}") do |faraday|
faraday.request :multipart
faraday.request :url_encoded
# faraday.use FaradayMiddleware::FollowRedirects, limit: | ruby | {
"resource": ""
} |
q6308 | Coinstack.Printer.pretty_print_user_list | train | def pretty_print_user_list(list)
total = 0
data = []
# Header row
data.push('Asset', 'Total Value', 'Change % (Week)')
list.user_pairs.each do |user_pair|
data.push(user_pair.symbol)
data.push(user_pair.valuation.format)
data.push(user_pair.perchant_change_week.to_s... | ruby | {
"resource": ""
} |
q6309 | Coinstack.Printer.print_arrays | train | def print_arrays(data, cols)
formatted_list = cli.list(data, | ruby | {
"resource": ""
} |
q6310 | Coinstack.Printer.array_char_length | train | def array_char_length(input_array)
length = 0
input_array.each do |a|
| ruby | {
"resource": ""
} |
q6311 | ContextFilters::Filters.Filters.select_filters | train | def select_filters(target, options)
found = filters_store.fetch(options, [])
if
Hash === options || options.nil?
then
options ||={}
options.merge!(:target => target)
found +=
# can not @filters.fetch(options, []) to allow filters provide custom ==()
| ruby | {
"resource": ""
} |
q6312 | Parse.Object.save_eventually | train | def save_eventually
block = block_given? ? Proc.new : nil
_self = self
Parse::Stack::Async.run do
begin
result = true
_self.save!
rescue => e
result = false
puts "[SaveEventually] Failed for object #{_self.parse_class}##{_self.id}: #{e}" | ruby | {
"resource": ""
} |
q6313 | Parse.Object.destroy_eventually | train | def destroy_eventually
block = block_given? ? Proc.new : nil
_self = self
Parse::Stack::Async.run do
begin
result = true
_self.destroy
rescue => e
result = false
puts "[DestroyEventually] Failed for object | ruby | {
"resource": ""
} |
q6314 | Myreplicator.MysqlExporter.export_table | train | def export_table export_obj
@export_obj = export_obj
ExportMetadata.record(:table => @export_obj.table_name,
:database => @export_obj.source_schema,
:export_to => load_to,
:export_id => @export_obj.id,
... | ruby | {
"resource": ""
} |
q6315 | Myreplicator.MysqlExporter.initial_export | train | def initial_export metadata
metadata.export_type = "initial"
max_value = @export_obj.max_value if @export_obj.incremental_export?
cmd = initial_mysqldump_cmd
exporting_state_trans # mark exporting
puts | ruby | {
"resource": ""
} |
q6316 | Myreplicator.MysqlExporter.incremental_export_into_outfile | train | def incremental_export_into_outfile metadata
unless @export_obj.is_running?
if @export_obj.export_type == "incremental"
max_value = @export_obj.max_value
metadata.export_type = "incremental"
@export_obj.update_max_val if @export_obj.max_incremental_value.blan... | ruby | {
"resource": ""
} |
q6317 | Myreplicator.MysqlExporter.check_result | train | def check_result result, size
unless result.nil?
raise | ruby | {
"resource": ""
} |
q6318 | Myreplicator.MysqlExporter.zipfile | train | def zipfile metadata
cmd = "cd #{Myreplicator.configs[@export_obj.source_schema]["ssh_tmp_dir"]}; gzip #{@export_obj.filename}"
puts cmd
zip_result = metadata.ssh.exec!(cmd)
unless zip_result.nil? | ruby | {
"resource": ""
} |
q6319 | Thermometer.Configuration.load_time_ranges | train | def load_time_ranges
@time_ranges = ActiveSupport::HashWithIndifferentAccess.new
time_ranges = @config['time']
time_ranges.each do |t,r|
time_range = ActiveSupport::HashWithIndifferentAccess.new
src_ranges | ruby | {
"resource": ""
} |
q6320 | Thermometer.Configuration.rangify_time_boundaries | train | def rangify_time_boundaries(src)
src.split("..").inject{ |s,e| | ruby | {
"resource": ""
} |
q6321 | APPI.HandlesResources.klass_for_type | train | def klass_for_type(type, singular=false)
type = type.singularize unless singular | ruby | {
"resource": ""
} |
q6322 | APPI.HandlesResources.resource_params | train | def resource_params
attributes = find_in_params(:attributes).try(:permit, permitted_attributes) || {}
relationships = {}
# Build Relationships Data
relationships_in_payload = find_in_params(:relationships)
if relationships_in_payload
raw_relationships = relationships_in_p... | ruby | {
"resource": ""
} |
q6323 | Lightstreamer.StreamConnectionHeader.process_line | train | def process_line(line)
@lines << line
return process_success if @lines.first == 'OK'
return process_error if @lines.first == 'ERROR'
return process_end if @lines.first == 'END'
| ruby | {
"resource": ""
} |
q6324 | Xpay.TransactionQuery.create_request | train | def create_request
raise AttributeMissing.new "(2500) TransactionReference or OrderReference need to be present." if (transaction_reference.nil? && order_reference.nil?)
raise AttributeMissing.new "(2500) SiteReference must be present." if (site_reference.nil? && (REXML::XPath.first(@request_xml, "//SiteRef... | ruby | {
"resource": ""
} |
q6325 | Cashboard.TimeEntry.toggle_timer | train | def toggle_timer
options = self.class.merge_options()
options.merge!({:body => self.to_xml})
response = self.class.put(self.links[:toggle_timer], options)
# Raise special errors if not a success | ruby | {
"resource": ""
} |
q6326 | Ducktrap.Error.dump | train | def dump(output)
output.name(self)
output.attribute(:input, | ruby | {
"resource": ""
} |
q6327 | AgileZen.Stories.project_story | train | def project_story(project_id, story_id, options={})
response_body = nil
begin
response = connection.get do |req|
req.url "/api/v1/projects/#{project_id}/story/#{story_id}", options
end
| ruby | {
"resource": ""
} |
q6328 | DatabaseCachedAttribute.ClassMethods.database_cached_attribute | train | def database_cached_attribute(*attrs)
attrs.each do |attr|
define_method("invalidate_#{attr}") do |arg=nil| # default arg to allow before_blah callbacks
invalidate_cache attr.to_sym
end
define_method("only_#{attr}_changed?") do
| ruby | {
"resource": ""
} |
q6329 | NameableRecord.Name.to_s | train | def to_s( pattern='%l, %f' )
if pattern.is_a?( Symbol )
return conversational if pattern == :conversational
return sortable if pattern == :sortable
| ruby | {
"resource": ""
} |
q6330 | NameableRecord.Name.sortable | train | def sortable
[
last,
[
prefix,
first,
middle,
| ruby | {
"resource": ""
} |
q6331 | Varnish.Client.vcl | train | def vcl(op, *params)
response = cmd("vcl.#{op}", *params)
case op
when :list
response.split("\n").map do |line|
a = line.split(/\s+/, 3)
| ruby | {
"resource": ""
} |
q6332 | Varnish.Client.purge | train | def purge(*args)
c = 'purge'
c << ".#{args.shift}" if [:url, :hash, :list].include?(args.first)
response = cmd(c, *args)
case c
when 'purge.list'
response.split("\n").map do |line|
| ruby | {
"resource": ""
} |
q6333 | Varnish.Client.stats | train | def stats
result = cmd("stats")
Hash[*result.split("\n").map { |line|
stat = line.strip!.split(/\s+/, 2)
| ruby | {
"resource": ""
} |
q6334 | BarkestCore.PdfTableBuilder.last_column | train | def last_column
max = 0
@data.each do |row|
max | ruby | {
"resource": ""
} |
q6335 | BarkestCore.PdfTableBuilder.build_column | train | def build_column(start_column = nil)
if block_given?
raise StandardError.new('build_column block called within row block') if @in_row
raise StandardError.new('build_column called without valid argument') unless start_column.is_a?(Numeric)
backup_col_start = @col_start
backup_col_o... | ruby | {
"resource": ""
} |
q6336 | BarkestCore.PdfTableBuilder.row | train | def row(options = {}, &block)
raise StandardError.new('row called within row block') if @in_row
@in_row = true
@col_offset = @col_start
options = change_row(options || {})
@row_cell_options = @base_cell_options.merge(options)
fill_cells(@row_offset, @col_offset)
# skip plac... | ruby | {
"resource": ""
} |
q6337 | BarkestCore.PdfTableBuilder.subtable | train | def subtable(cell_options = {}, options = {}, &block)
raise StandardError.new('subtable called outside of row block') unless @in_row
cell cell_options || {} do
| ruby | {
"resource": ""
} |
q6338 | BarkestCore.PdfTableBuilder.cells | train | def cells(options = {}, &block)
cell_regex = /^cell_([0-9]+)_/
options ||= { }
result = block_given? ? yield : (options[:values] || [''])
cell_options = result.map { {} }
common_options = {}
options.each do |k,v|
# if the option starts with 'cell_#_' then apply it accordi... | ruby | {
"resource": ""
} |
q6339 | BarkestCore.PdfTableBuilder.cell | train | def cell(options = {}, &block)
raise StandardError.new('cell called outside of row block') unless @in_row
options = @row_cell_options.merge(options || {})
options = change_col(options)
| ruby | {
"resource": ""
} |
q6340 | BarkestCore.PdfTableBuilder.fix_row_widths | train | def fix_row_widths
fill_cells(@row_offset - 1, 0)
max = 0
@data.each_with_index do |row|
max = row.length unless max >= row.length
end
@data.each_with_index do |row,idx|
if row.length < max
| ruby | {
"resource": ""
} |
q6341 | TicTacToe.Board.empty_positions | train | def empty_positions(&block)
positions = []
each_position do |row, column|
next if get_cell(row, column)
| ruby | {
"resource": ""
} |
q6342 | TicTacToe.Board.solved? | train | def solved?
letter = won_across?
return letter if letter
letter = won_up_and_down?
return letter if letter
letter = | ruby | {
"resource": ""
} |
q6343 | Buzztools.Config.read | train | def read(aSource,&aBlock)
default_values.each do |k,v|
done = false
if block_given? && ((newv = yield(k,v,aSource && aSource[k])) != nil)
self[k] = newv
done | ruby | {
"resource": ""
} |
q6344 | Buzztools.Config.reset | train | def reset
self.clear
me = self
@default_values.each {|n,v| me[n] | ruby | {
"resource": ""
} |
q6345 | Snapshotify.Writer.ensure_directory | train | def ensure_directory
dir = File.dirname(full_filename)
unless File.directory?(dir)
| ruby | {
"resource": ""
} |
q6346 | Snapshotify.Writer.filename | train | def filename
# Based on the path of the file
path = resource.url.uri.path
# It's either an index.html file
# if the path ends with a slash
if path.end_with?('/')
return path + 'index.html'
# Or it's also an index.html if it ends
# without a slah yet is not a file with a... | ruby | {
"resource": ""
} |
q6347 | Jinx.Hasher.assoc_values | train | def assoc_values(*others)
all_keys = keys
others.each { |hash| all_keys.concat(hash.keys) }
all_keys.to_compact_hash do |k|
| ruby | {
"resource": ""
} |
q6348 | Jinx.Hasher.enum_keys_with_value | train | def enum_keys_with_value(target_value=nil, &filter) # :yields: value
return | ruby | {
"resource": ""
} |
q6349 | Jinx.Hasher.copy_recursive | train | def copy_recursive
copy = Hash.new
keys.each do |k|
value = | ruby | {
"resource": ""
} |
q6350 | RDSBackup.Email.body | train | def body
msg = "Hello.\n\n"
if job.status == 200
msg += "Your backup of database #{job.rds_id} is complete.\n"+
(job.files.empty? ? "" : "Output is at #{job.files.first[:url]}\n")
else
| ruby | {
"resource": ""
} |
q6351 | BootstrapsBootstraps.BootstrapFormHelper.bootstrapped_form | train | def bootstrapped_form object, options={}, &block
options[:builder] = BootstrapFormBuilder
| ruby | {
"resource": ""
} |
q6352 | Maturate.InstanceMethods.api_version | train | def api_version
version = params[:api_version]
return current_api_version if version == 'current'
| ruby | {
"resource": ""
} |
q6353 | TrackableTasks.Base.allowable_log_level | train | def allowable_log_level(log_level)
log_level = "" if log_level.nil?
log_level = log_level.to_sym unless log_level.is_a?(Symbol)
if | ruby | {
"resource": ""
} |
q6354 | TrackableTasks.Base.run_task | train | def run_task
begin
run
rescue Exception => e
@task_run.add_error_text(e.class.name + ": " + e.message)
@task_run.add_error_text(e.backtrace.inspect)
@task_run.success | ruby | {
"resource": ""
} |
q6355 | Mobilize.Runner.force_due | train | def force_due
r = self
r.update_attributes(:started_at=>(Time.now.utc | ruby | {
"resource": ""
} |
q6356 | TriglavClient.UsersApi.create_user | train | def create_user(user, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q6357 | TriglavClient.UsersApi.get_user | train | def get_user(id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q6358 | TriglavClient.UsersApi.update_user | train | def update_user(id, user, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q6359 | Dater.Resolver.time_for_period | train | def time_for_period(string=nil)
@last_date = case string
when /today/,/now/
now
when /tomorrow/
tomorrow_time
when /yesterday/
yesterday_time
when /sunday/, /monday/, /tuesday/, /wednesday/, /thursday/, /friday/, /saturday/
time_for_weekday(string)
when /next/
... | ruby | {
"resource": ""
} |
q6360 | Dater.Resolver.is_required_day? | train | def is_required_day?(time, day)
day_to_ask = "#{day}?"
result | ruby | {
"resource": ""
} |
q6361 | Dater.Resolver.multiply_by | train | def multiply_by(string)
return minute_mult(string) || hour_mult(string) || day_mult(string) || week_mult(string) | ruby | {
"resource": ""
} |
q6362 | Dater.Resolver.time_from_date | train | def time_from_date(date)
numbers=date.scan(/\d+/).map!{|i| i.to_i} | ruby | {
"resource": ""
} |
q6363 | Dater.Resolver.method_missing | train | def method_missing(meth)
self.class.send :define_method, meth do
string = meth.to_s.gsub("_"," ")
self.for("for('#{string}')")
end
begin
| ruby | {
"resource": ""
} |
q6364 | Incline.ActionSecurity.update_flags | train | def update_flags
self.allow_anon = self.require_anon = self.require_admin = self.unknown_controller = self.non_standard = false
self.unknown_controller = true
klass = ::Incline.get_controller_class(controller_name)
if klass
self.unknown_controller = false
if klass.require_admin... | ruby | {
"resource": ""
} |
q6365 | Incline.ActionSecurity.permitted | train | def permitted(refresh = false)
@permitted = nil if refresh
@permitted ||=
if require_admin?
'Administrators Only'
elsif require_anon?
'Anonymous Only'
elsif allow_anon?
'Everyone'
elsif groups.any?
names = groups.pluck(:... | ruby | {
"resource": ""
} |
q6366 | Incline.ActionSecurity.group_ids= | train | def group_ids=(values)
values ||= []
values = [ values ] unless values.is_a?(::Array)
values = values.reject{|v| | ruby | {
"resource": ""
} |
q6367 | TheViking.Akismet.check_comment | train | def check_comment(options = {})
return false if invalid_options?
message = call_akismet('comment-check', options)
{ :spam | ruby | {
"resource": ""
} |
q6368 | TheViking.Akismet.call_akismet | train | def call_akismet(akismet_function, options = {})
http_post(
Net::HTTP.new([self.options[:api_key], self.class.host].join('.'), options[:proxy_host], options[:proxy_port]),
| ruby | {
"resource": ""
} |
q6369 | Evvnt.Actions.define_action | train | def define_action(action, &block)
action = action.to_sym
defined_actions << action unless defined_actions.include?(action)
if action.in?(Evvnt::ClassTemplateMethods.instance_methods)
define_class_action(action, &block)
end
| ruby | {
"resource": ""
} |
q6370 | BROpenData.ParentService.get_request | train | def get_request(hash=true)
resp = RestClient.get get_url
| ruby | {
"resource": ""
} |
q6371 | EcomDev::ChefSpec::Helpers.Platform.filter | train | def filter(*conditions)
latest = !conditions.select {|item| item === true }.empty?
filters = translate_conditions(conditions)
items = list(latest)
unless filters.empty?
items = items.select do |item|
| ruby | {
"resource": ""
} |
q6372 | EcomDev::ChefSpec::Helpers.Platform.is_version | train | def is_version(string)
return false if string === false || string === true || string.nil?
| ruby | {
"resource": ""
} |
q6373 | EcomDev::ChefSpec::Helpers.Platform.is_os | train | def is_os(string)
return false if string === false || string === true | ruby | {
"resource": ""
} |
q6374 | EcomDev::ChefSpec::Helpers.Platform.match_filter | train | def match_filter(filter, item)
filter.each_pair do |key, value|
unless item.key?(key)
return false
end
unless value.is_a?(Array)
return false if value != item[key]
else
| ruby | {
"resource": ""
} |
q6375 | EcomDev::ChefSpec::Helpers.Platform.list | train | def list(latest = false)
result = []
@os.map do |os, versions|
unless latest
versions.each { |version| result << {os: os, version: version}}
else
| ruby | {
"resource": ""
} |
q6376 | StalkClimber.Connection.fetch_and_cache_job | train | def fetch_and_cache_job(job_id)
job = fetch_job(job_id)
self.cached_jobs[job_id] = job unless job.nil?
@min_climbed_job_id = job_id if job_id < @min_climbed_job_id
| ruby | {
"resource": ""
} |
q6377 | Mycroft.Messages.connect_to_mycroft | train | def connect_to_mycroft
if ARGV.include?("--no-tls")
@client = TCPSocket.open(@host, @port)
else
socket = TCPSocket.new(@host, @port)
ssl_context = OpenSSL::SSL::SSLContext.new
ssl_context.cert = OpenSSL::X509::Certificate.new(File.open(@cert))
| ruby | {
"resource": ""
} |
q6378 | Mycroft.Messages.send_manifest | train | def send_manifest
begin
manifest = JSON.parse(File.read(@manifest))
manifest['instanceId'] = "#{Socket.gethostname}_#{SecureRandom.uuid}" if @generate_instance_ids
| ruby | {
"resource": ""
} |
q6379 | Mycroft.Messages.query | train | def query(capability, action, data, priority = 30, instance_id = nil)
query_message = {
id: SecureRandom.uuid,
capability: capability,
action: action,
data: data,
priority: priority,
| ruby | {
"resource": ""
} |
q6380 | Mycroft.Messages.broadcast | train | def broadcast(content)
message = {
id: SecureRandom.uuid,
content: content
}
| ruby | {
"resource": ""
} |
q6381 | LitePage.PageInitializers.visit | train | def visit(page_class, query_params = {}, browser = @browser)
page = page_class.new(browser)
url = query_params.empty? ? page.page_url : | ruby | {
"resource": ""
} |
q6382 | LitePage.PageInitializers.on | train | def on(page_class, browser = @browser)
page = | ruby | {
"resource": ""
} |
q6383 | Konfig.Store.load_directory | train | def load_directory(path)
unless File.directory?(path)
raise "Konfig couldn't load because it was unable to | ruby | {
"resource": ""
} |
q6384 | Konfig.Store.load_file | train | def load_file(path)
d = YAML.load_file(path)
if d.is_a?(Hash)
d = HashWithIndifferentAccess.new(d)
e = Evaluator.new(d)
| ruby | {
"resource": ""
} |
q6385 | Bebox.ProfileCommands.profile_new_command | train | def profile_new_command(profile_command)
profile_command.desc _('cli.profile.new.desc')
profile_command.arg_name "[name]"
profile_command.command :new do |profile_new_command|
profile_new_command.flag :p, :arg_name => 'path', :desc => _('cli.profile.new.path_flag_desc')
profile_new_com... | ruby | {
"resource": ""
} |
q6386 | Bebox.ProfileCommands.profile_remove_command | train | def profile_remove_command(profile_command)
profile_command.desc _('cli.profile.remove.desc')
profile_command.command :remove do |profile_remove_command|
| ruby | {
"resource": ""
} |
q6387 | Bebox.ProfileCommands.profile_list_command | train | def profile_list_command(profile_command)
profile_command.desc _('cli.profile.list.desc')
profile_command.command :list do |profile_list_command|
profile_list_command.action do |global_options,options,args|
| ruby | {
"resource": ""
} |
q6388 | ARK.TextBuilder.wrap | train | def wrap(width: 78, indent: 0, indent_after: false, segments: false)
if segments
text = Text.wrap_segments(@lines[@line], width: width, indent: indent, indent_after: indent_after)
else
text = Text.wrap(@lines[@line], width: width, indent: | ruby | {
"resource": ""
} |
q6389 | Shopsense.API.search | train | def search( search_string = nil, index = 0, num_results = 10)
raise "no search string provieded!" if( search_string === nil)
fts = "fts=" | ruby | {
"resource": ""
} |
q6390 | Shopsense.API.get_look | train | def get_look( look_id = nil)
raise "no look_id provieded!" if( look_id === nil)
| ruby | {
"resource": ""
} |
q6391 | Shopsense.API.get_stylebook | train | def get_stylebook( user_name = nil, index = 0, num_results = 10)
raise "no user_name provieded!" if( user_name === nil)
handle = "handle=" + user_name.to_s
min = "min=" + index.to_s
count = "count=" + | ruby | {
"resource": ""
} |
q6392 | Shopsense.API.get_looks | train | def get_looks( look_type = nil, index = 0, num_results = 10)
raise "invalid filter type must be one of the following: #{self.look_types}" if( !self.look_types.include?( look_type))
type = "type=" + look_type.to_s
min = "min=" + index.to_s | ruby | {
"resource": ""
} |
q6393 | Shopsense.API.get_trends | train | def get_trends( category = "", products = 0)
cat = "cat=" + category.to_s
products = | ruby | {
"resource": ""
} |
q6394 | Shopsense.API.call_api | train | def call_api( method, args = nil)
method_url = self.api_url + self.send( "#{method}_path")
pid = "pid=" + self.partner_id
format = "format=" + self.format
site = "site=" + self.site
if( args === nil) then
| ruby | {
"resource": ""
} |
q6395 | Numerals.Format::Symbols::Digits.digits_text | train | def digits_text(digit_values, options={})
insignificant_digits = options[:insignificant_digits] || 0
num_digits = digit_values.reduce(0) { |num, digit|
digit.nil? ? num : num + 1
}
num_digits -= insignificant_digits
| ruby | {
"resource": ""
} |
q6396 | Woro.TaskList.width | train | def width
@width ||= list.map { |t| t.name_with_args | ruby | {
"resource": ""
} |
q6397 | Woro.TaskList.print | train | def print
list.each do |entry|
entry.headline | ruby | {
"resource": ""
} |
q6398 | Garcon.Event.wait | train | def wait(timeout = nil)
@mutex.lock
unless @set
remaining = Condition::Result.new(timeout)
while | ruby | {
"resource": ""
} |
q6399 | Sumac.RemoteObject.method_missing | train | def method_missing(method_name, *arguments, &block) # TODO: blocks not working yet
arguments << block.to_lambda if block_given?
reqeust = {object: self, method: method_name.to_s, arguments: arguments}
begin
| 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.