query stringlengths 7 9.55k | document stringlengths 10 363k | metadata dict | negatives listlengths 0 101 | negative_scores listlengths 0 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
shows win or remaining turns | def check_win
if win
puts "\n You win!"
else
# shows how many turns remain
puts "\n You have #{TURNS - @turns} turns left"
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_current_turn\n puts \"Turn #{@turn + 1}, Player #{(@turn % 2) + 1}\"\n end",
"def turn\n puts \"Turn #{@board.count_turn + 1}, player #{get_current_player.name} choose:\"\n @board.play_turn\n end",
"def game_over\n print_board\n if victor?\n puts \"#{self.victor?} is the v... | [
"0.72572136",
"0.70798755",
"0.70409554",
"0.7037158",
"0.702491",
"0.69814044",
"0.69770944",
"0.6973264",
"0.69639254",
"0.6942884",
"0.6899964",
"0.6872847",
"0.6869406",
"0.685956",
"0.6855578",
"0.6855283",
"0.6837401",
"0.68186736",
"0.6803984",
"0.678885",
"0.67547196"... | 0.79604405 | 0 |
asks user if rematch desired | def play_again
puts "\n Would you like to play again? y/n"
answer = gets.chomp.downcase
if answer == ("y" || "yes")
Game.new.play
else
puts "\n Thank you for playing!"
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def match(input); end",
"def match(input)\n input \n end",
"def post_match() end",
"def match\n true\n end",
"def match; end",
"def match; end",
"def do_match(input)\n @matched = input.match(@on)\n end",
"def match?(name); end",
"def match_query(query); end",
"def is_correct?\n ... | [
"0.7011139",
"0.67534256",
"0.67057437",
"0.67008364",
"0.66900986",
"0.66900986",
"0.66409534",
"0.6579448",
"0.6474582",
"0.6447216",
"0.6431372",
"0.64192677",
"0.641826",
"0.64103645",
"0.64096105",
"0.6364916",
"0.63455373",
"0.6317084",
"0.6205512",
"0.6171907",
"0.6171... | 0.0 | -1 |
I think the answer to this is creating a new tag named [youtube] but that captures specifically the .be or .com and treats them differently... | def test_youtubes_via_there_url_shortener
url_from_shortener = 'http://youtu.be/E4Fbk52Mk1w'
expected_output = 'E4Fbk52Mk1w'
mock_regex_matches = @@tags[:youtube][:url_matches]
RubyBBCode::TagSifter.publicize_methods do
ts = RubyBBCode::TagSifter.new '', ''
# this test is now hopelessly broken because generating an ID from a link requires that @bbtree.current_node.definition be properly populated with regex matches...
assert_equal expected_output, ts.match_url_id(url_from_shortener, mock_regex_matches)
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def markdown_extention_youtube_links(html)\n html = html.gsub /<a\\shref=\"http:\\/\\/www\\.youtube\\.com\\/watch\\?v=(.*).*\".*>.*<\\/a>/o, \n \"<p><iframe class=\\\"youtube-player\\\" src=\\\"http://www.youtube.com/embed/\\\\1\\\"></iframe></p>\"\n return html\n end",
"def youtube_tag(url, opts = {... | [
"0.65621305",
"0.6414589",
"0.63338876",
"0.63235843",
"0.600453",
"0.599909",
"0.599909",
"0.5985747",
"0.5940273",
"0.59085023",
"0.58426166",
"0.5777521",
"0.57654804",
"0.5755335",
"0.5746571",
"0.5734595",
"0.57175404",
"0.57151335",
"0.56865245",
"0.56723386",
"0.563342... | 0.56155217 | 22 |
I worked on this challenge by myself psuedocode input: integer output: factorial of that interger establish a loop to keep subracting one and only work when number is bigger than 0 have the number multiplied by the next iteration of it or the one less by one. have a conditional for factorial 0 to be 1 return the result Your Solution Below | def factorial(number)
if (number >= 2)
result.each do |number| number * (number -1)
number -=
end
return result
else
number == 0 || number == 1
return 1
end
end
#This is as close as i got to getting factorial to work without using refactoring, per instructions.
#Couldnt really get this to work. | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def factorial(number)\n counter = number.to_i - 1\n if number.to_i == 0\n return 1\n else\n while counter > 0\n number = number * counter\n counter = counter - 1\n end\nend\nreturn number\nend",
"def factorial(number)\n result=1\n #if number == 0\n # return 1\n else\n while (number>0)\n ... | [
"0.8708291",
"0.8556082",
"0.8511055",
"0.85107446",
"0.84791315",
"0.8438253",
"0.8427472",
"0.8422243",
"0.84174275",
"0.8413844",
"0.8413844",
"0.8394853",
"0.83772993",
"0.8375461",
"0.83621186",
"0.83244276",
"0.83084905",
"0.82917434",
"0.82899195",
"0.8286861",
"0.8278... | 0.8114296 | 47 |
It also uses `map/projects_statistics.csv` file to get a list of projects that needs to be included in rank statistics. Output rank statistics file is `projects/project_ranks.txt` | def analysis(fin, fout, fhint, furls, fdefmaps, fskip, franges)
sort_col = 'authors'
forks = ENV.has_key? 'INCLUDE_FORKS'
unless forks
require 'json'
require 'octokit'
require './ghapi'
gcs = octokit_init()
hint = rate_limit(gcs)[0]
fork_data = {}
$g_forks_file = ENV['FORKS_FILE'] if ENV.key? 'FORKS_FILE'
begin
data = JSON.parse File.read $g_forks_file
data.each do |row|
repo = row[0]
is_fork = row[1]
fork_data[repo] = is_fork
end
rescue => err
STDERR.puts [err.class, err]
end
Signal.trap('INT') do
puts "Caught signal, saving forks cache"
pretty = JSON.pretty_generate fork_data
File.write $g_forks_file, pretty
puts "Saved"
exit 1
end
end
# Repos, Orgs and Projects to skip
skip_repos = {}
skip_orgs = {}
skip_projs = {}
CSV.foreach(fskip, headers: true) do |row|
next if is_comment row
h = row.to_h
org = (h['org'] || '').strip
repo = (h['repo'] || '').strip
proj = (h['project'] || '').strip
if org.length > 0
orgs = org.split(',')
orgs.each do |o|
if skip_orgs.key?(o)
puts "Duplicate skip org entry: #{o}"
return
end
skip_orgs[o] = true
end
end
if repo.length > 0
reps = repo.split(',')
reps.each do |r|
if skip_repos.key?(r)
puts "Duplicate skip repo entry: #{r}"
return
end
skip_repos[r] = true
end
end
if proj.length > 0
projs = proj.split(',')
projs.each do |p|
if skip_projs.key?(p)
puts "Duplicate skip project entry: #{p}"
return
end
skip_projs[p] = true
end
end
end
# Min/Max ranges for integer columns (with exceptions)
ranges = {}
CSV.foreach(franges, headers: true) do |row|
next if is_comment row
h = row.to_h
key = h['key'].strip
min = h['min'].strip
max = h['max'].strip
exc = (h['exceptions'] || '').strip
rps = {}
ors = {}
excs = exc.split(',')
excs.each do |ex|
next if ex == ''
if ex.include?('/')
if rps.key?(ex)
puts "Duplicate exception repo entry: #{ex}"
return
end
rps[ex] = true
else
if ors.key?(ex)
puts "Duplicate exception org entry: #{ex}"
return
end
ors[ex] = true
end
end
if ranges.key?(key)
puts "Duplicate ranges key: #{key}"
return
end
ranges[key] = [min.to_i, max.to_i, ors, rps]
end
# Repo --> Project mapping
hints_comments = []
File.readlines(fhint).each do |line|
hints_comments << line if line[0] == '#'
end
projects = {}
CSV.foreach(fhint, headers: true) do |row|
next if is_comment row
h = row.to_h
proj = (h['project'] || '').strip
repo = (h['repo'] || '').strip
if proj == '' || repo == ''
puts "Invalid hint: project='#{proj}' repo='#{repo}'"
return
end
if projects.key?(repo)
if projects[repo] != proj
puts "Non unique entry: projects: projects['#{repo}'] = '#{projects[repo]}', new value: #{proj}"
else
puts "Duplicate entry: projects: projects['#{repo}'] = '#{projects[repo]}'"
end
return
end
projects[repo] = proj
end
# Sort hints files on the fly (program user manually updates that file while working so it should be sorted all the time)
hdr = ['repo', 'project']
CSV.open(fhint, "w", headers: hdr) do |csv|
csv << hdr
projects.keys.sort.each do |repo|
csv << [repo, projects[repo]]
end
end
File.open(fhint, 'a') do |file|
hints_comments.sort.each { |comment| file.write(comment) }
end
# Project --> URL mapping (it uses final project name after all mappings, including defmaps.csv)
urls_comments = []
File.readlines(furls).each do |line|
urls_comments << line if line[0] == '#'
end
urls = {}
CSV.foreach(furls, headers: true) do |row|
next if is_comment row
h = row.to_h
proj = (h['project'] || '').strip
url = (h['url'] || '').strip
if proj == '' || url == ''
puts "Invalid URL: project='#{proj}' url='#{url}'"
return
end
if urls.key?(proj)
if urls[proj] != url
puts "Non unique entry: urls: urls['#{proj}'] = '#{urls[proj]}', new value: #{url}"
else
puts "Duplicate entry: urls: urls['#{proj}'] = '#{urls[proj]}'"
end
return
end
urls[proj] = url
end
# Sort URLs files on the fly (program user manually updates that file while working so it should be sorted all the time)
hdr = ['project', 'url']
CSV.open(furls, "w", headers: hdr) do |csv|
csv << hdr
urls.keys.sort.each do |project|
csv << [project, urls[project]]
end
end
File.open(furls, 'a') do |file|
urls_comments.sort.each { |comment| file.write(comment) }
end
# Final name --> new name mapping (defmaps)
# Used to create better names for projects auto generated just from org or repo name
# And/Or to group multiple orgs, repos, projects or combinations of all into single project
# For example we can create "XYZ" project for sum of "Kubernetes" and "dotnet" via:
# name,project
# Kubernetes,XYZ
# dotnet,XYZ
defmaps_comments = []
File.readlines(fdefmaps).each do |line|
defmaps_comments << line if line[0] == '#'
end
defmaps = {}
skip_group = {}
CSV.foreach(fdefmaps, headers: true) do |row|
next if is_comment row
h = row.to_h
name = (h['name'] || '').strip
project = (h['project'] || '').strip
if project == '' || name == ''
puts "Invalid defmap: project='#{project}' name='#{name}'"
return
end
# Handle skip groupping this org
if project.downcase == '=skip'
project = project[1..-1]
if skip_group.key?(name)
puts "Duplicate entry: defmaps: skip_group['#{name}']"
return
end
skip_group[name] = true
next
end
if defmaps.key?(name)
if defmaps[name] != project
puts "Non unique entry: defmaps: defmaps['#{name}'] = '#{defmaps[name]}', new value: #{project}"
else
puts "Duplicate entry: defmaps: defmaps['#{name}'] = '#{defmaps[name]}'"
end
return
end
defmaps[name] = project
end
# Sort defmaps files on the fly (program user manually updates that file while working so it should be sorted all the time)
hdr = ['name', 'project']
CSV.open(fdefmaps, "w", headers: hdr) do |csv|
csv << hdr
skip_group.keys.sort.each do |name|
csv << [name, '=SKIP']
end
defmaps.keys.sort.each do |name|
csv << [name, defmaps[name]]
end
end
File.open(fdefmaps, 'a') do |file|
defmaps_comments.sort.each { |comment| file.write(comment) }
end
# Missing URLs: will abort program: if somebody care to define some project (via hints, defmaps or whatever) then let's force him/her to define project URL as well
# This won't complain about autogenerated projects (like sum of org repos etc)
urls_found = true
projects.values.uniq.each do |project|
unless urls.key? project
puts "Project '#{project}' have no URL defined, aborting"
urls_found = false
end
end
defmaps.values.uniq.each do |project|
unless urls.key? project
puts "Defmap Project '#{project}' have no URL defined, aborting"
urls_found = false
end
end
return unless urls_found
# Analysis:
# Get repo name from CSV row
# If repo found in projects set mode to "project" and groupping
# If project not found and "org" is present set mode to "org" and groupping
# If mode not determined yet set it to repo
# Now check if final project key (project, org or repo) is in additional mapping
# Additional mapping is used to:
# create better name for data groupped by org (when default is enough) like org = "aspnet" --> ASP.net
# group multiple orgs and orgs with repos into single project
orgs = {}
project_counts = {}
all_repos = {}
n_rows = CSV.foreach(fin, headers: true).count
CSV.foreach(fin, headers: true).with_index do |row, i|
next if is_comment row
h = row.to_h
# skip repos & orgs
repo = h['repo']
unless forks
hint, is_fork = is_fork?(gcs, hint, fork_data, repo, i, n_rows)
next if is_fork
end
all_repos[repo] = true
next if skip_repos.key? repo
org = h['org']
next if skip_orgs.key? org
a = h['authors']
if a[0] == '=' && a[1..-1].to_i > 0
n = a[1..-1].to_i
h['authors'] = (1..n).to_a.join(',')
end
a = h['authors_alt1']
if a[0] == '=' && a[1..-1].to_i > 0
n = a[1..-1].to_i
h['authors_alt1'] = (1..n).to_a.join(',')
end
# skip by values ranges
skip = false
ranges.each do |key, value|
min_v, max_v, ors, rps = *value
next if ors.key? org
next if rps.key? repo
unless key == 'authors'
v = h[key].to_i
else
v = h[key].split(',').uniq.count
end
if min_v > 0 && v < min_v
skip = true
break
end
if max_v > 0 && v > max_v
skip = true
break
end
end
next if skip
k = h['project'] = projects[repo]
mode = nil
if k
project_counts[k] = [0, []] unless project_counts.key?(k)
project_counts[k][0] += 1
project_counts[k][1] << repo
mode = 'project'
end
# Is this org defined to skip groupping?
org = nil if skip_group.key? org
k = org unless k
mode = 'org' if k && !mode
k = h['repo'] unless k
next unless k
mode = 'repo' unless mode
if defmaps.key? k
k = defmaps[k]
mode = 'defmap'
end
h['project'] = k
h['mode'] = mode
next if skip_projs.key?(k)
orgs[k] = { items: [] } unless orgs.key? k
h.each do |p, v|
vi = v.to_i
vis = vi.to_s
h[p] = vi if vis == v
end
orgs[k][:items] << h
end
unless forks
pretty = JSON.pretty_generate fork_data
File.write $g_forks_file, pretty
end
orgs.each do |name, org|
org[:sum] = {}
org[:items].each do |repo|
repo.each do |k, v|
if ['authors', 'authors_alt1'].include? k
if org[:sum].key? k
org[:sum][k] += ',' + v.to_s
else
org[:sum][k] = v.to_s
end
next
end
if v.is_a?(String)
if repo['org'] && k == 'repo' && v.include?('/')
v = v.split('/')[1]
end
if org[:sum].key? k
v = '' if v.nil?
org[:sum][k] = '' if org[:sum][k].nil?
org[:sum][k] += '+' + v
else
org[:sum][k] = v
end
elsif v.is_a?(Integer)
org[:sum][k] = 0 unless org[:sum].key? k
binding.pry if org[:sum][k].nil?
org[:sum][k] += v
else
org[:sum][k] = nil
end
end
end
new_org = org[:sum]['org'].to_s
org[:sum]['org'] = new_org.split('+').uniq.join('+') if new_org
new_prj = org[:sum]['project'].to_s
org[:sum]['project'] = new_prj.split('+').uniq.join('+') if new_prj
new_mode = org[:sum]['mode']
org[:sum]['mode'] = new_mode.split('+').uniq.join('+') if new_mode
org[:sum]['authors'] = org[:sum]['authors'].split(',').uniq.count
if org[:sum]['authors'] < 1
puts "WARNING: data from BigQuery truncated, no authors on current org: #{org[:sum]['project']}"
alt1 = org[:sum]['authors_alt1'].split(',').uniq.count
if alt1 > 1
puts "Alternate value used: #{alt1}"
org[:sum]['authors'] = alt1
else
puts "Very Alternate value used: #{org[:sum]['authors_alt2']}"
org[:sum]['authors'] = org[:sum]['authors_alt2']
end
binding.pry
end
end
# Sort by sort_col desc to get list of top projects
orgs_arr = []
orgs.each do |name, org|
orgs_arr << [name, org[:sum][sort_col], org]
end
res = orgs_arr.sort_by { |item| -item[1] }
# now create list of projects missing URL (`miss` variable to be seen in debugger)
# but only display and stop in debugger if any missing URL in top 50
# so if no URL is missing in Top 50 projects, it won't stop at this point, but missing URLs
# for projects >50th will still be in `miss` variable
no_url = false
miss = []
unmapped = {}
ract = {}
rcomm = {}
rauth = {}
rauth1 = {}
rauth2 = {}
rprs = {}
riss = {}
rpush = {}
res.each_with_index do |item, index|
sum = item[2][:sum]
project = sum['project']
ract[project] = item[2][:items].map { |i| [i['activity'], i['repo']] }.sort_by { |i| -i[0] }.map { |i| "#{i[1]},#{i[0]}" }
rcomm[project] = item[2][:items].map { |i| [i['commits'], i['repo']] }.sort_by { |i| -i[0] }.map { |i| "#{i[1]},#{i[0]}" }
rauth[project] = item[2][:items].map { |i| [i['authors'].split(',').uniq.count, i['repo']] }.sort_by { |i| -i[0] }.map { |i| "#{i[1]},#{i[0]}" }
rprs[project] = item[2][:items].map { |i| [i['prs'], i['repo']] }.sort_by { |i| -i[0] }.map { |i| "#{i[1]},#{i[0]}" }
riss[project] = item[2][:items].map { |i| [i['issues'], i['repo']] }.sort_by { |i| -i[0] }.map { |i| "#{i[1]},#{i[0]}" }
rpush[project] = item[2][:items].map { |i| [i['pushes'], i['repo']] }.sort_by { |i| -i[0] }.map { |i| "#{i[1]},#{i[0]}" }
rauth1[project] = item[2][:items].map { |i| [i['authors_alt1'].split(',').uniq.count, i['repo']] }.sort_by { |i| -i[0] }.map { |i| "#{i[1]},#{i[0]}" }
rauth2[project] = item[2][:items].map { |i| [i['authors_alt2'], i['repo']] }.sort_by { |i| -i[0] }.map { |i| "#{i[1]},#{i[0]}" }
if !urls.key?(project)
s = "Project ##{index} (#{sum['mode']}, #{sum[sort_col]}) #{project} (#{sum['org']}) (#{sum['repo']}) have no URL defined"
if index <= 50
unmapped[project] = item[2][:items].map { |i| [i['activity'], i['repo']] }.sort_by { |i| -i[0] }.map { |i| ("%-8d" % i[0]) + " #{i[1]}" }
puts s
no_url = true
end
miss << s
sum['url'] = ''
else
sum['url'] = urls[project]
end
end
puts "Use `unmapped` to see what needs to be defined" if no_url
binding.pry if no_url
puts 'res[0..30].map { |it| it[0] }'
puts "Defined projects: "
prjs = []
project_counts.keys.sort.each do |k|
prjs << "#{k}: #{project_counts[k][0]}"
end
prjs = prjs.join(', ')
puts prjs
# This is pretty print of what was found, it is displayed and program stops in debugger
# To see all projects use `all variable` if ok type "quit" to exit debugger and save results
puts "Top:"
tops = res[0..40].map.with_index { |it, idx| "#{idx}) #{it[0]} (#{it[2][:sum]['mode']} #{it[2][:sum]['url']}): #{it[1]} (#{it[2][:sum]['org']}) (#{it[2][:sum]['repo']})" }
all = res.map.with_index { |it, idx| "#{idx}) #{it[0]} (#{it[2][:sum]['mode']} #{it[2][:sum]['url']}): #{it[1]} (#{it[2][:sum]['org']}) (#{it[2][:sum]['repo']})" }
puts tops
puts "`all` to see all data, `miss` to see missing project's urls, `ract['key'] to see `key`'s repos sorted by activity desc (also rcomm, rauth, rprs, riss, rpush for commits, authors, PRs, issues, pushes)"
puts "Use `rauth[res[N][0]]` to examine what creates N-th top project, actually to have a good Top N data, You should define all data correctly for 0-N"
puts "Or by project name `rauth[res[res.map { |i| i[0] }.index('project_name')][0]]`"
puts "Project's index is: `res.map { |i| i[0] }.index('project_name')`, top N: `res.map { |i| i[0] }[0..N]`"
puts "List of 'Google' repos that have > 10 authors: `rauth[res[res.map { |i| i[0] }.index('Google')][0]].select { |i| i.split(',')[1].to_i > 10 }.map { |i| i.split(',')[0] }.join(',')`"
puts "See indices of projects contain something in name: `res.map.with_index { |e, i| [e, i] }.select { |e| e[0][0].include?('OpenStack') }.map { |e| \"\#{e[1]} \#{e[0][0]}\" }`"
puts "Nice view Top 50: `res.map.with_index { |e,i| \"\#{i+1} \#{e[0]}\" }[0..49]`"
puts "Dan loves it: `res[res.map { |i| i[0] }.index('Google Cloud')][2][:items].map { |i| [i['repo'], i['commits'], i['issues'], i['prs'], i['authors'].split(',').count] }.sort_by { |i| -i[1] }.map { |i| \"\#{i[0]}, commits: \#{i[1]}, issues: \#{i[2]}, PRs: \#{i[3]}, authors: \#{i[4]}\" }`"
puts "See Project's specific repo: `res[res.map { |i| i[0] }.index('openSUSE')][2][:items].select { |i| i['repo'] == 'openSUSE/kernel' }`"
puts "Project's Repo's real authors count: `res[res.map { |i| i[0] }.index('openSUSE')][2][:items].select { |i| i['repo'] == 'openSUSE/kernel' }.first['authors'].split(',').count`"
puts 'Projects matching regexp: `res.map.with_index { |e, i| [e, i] }.select { |e| e[0][0].match("/cloud/i".to_regexp) }.map { |e| "#{e[1]} #{e[0][0]}" }`'
puts 'Projects and authors: `res.each_with_index.map { |r, i| [i+1, r[0], r[1]] }`'
puts 'OpenStack analysis: `res.select { |r| r[0][0..8] == \'OpenStack\' }.map { |r| [r[0], r[1]] }`'
binding.pry
ks = res[0][2][:sum].keys - %w(mode authors_alt1 authors_alt2)
CSV.open(fout, "w", headers: ks) do |csv|
csv << ks
res.each do |row|
csv_row = []
ks.each do |key|
csv_row << row[2][:sum][key]
end
csv << csv_row
end
end
CSV.open('reports/all_repos.csv', "w", headers: ['repo']) do |csv|
csv << ['repo']
all_repos.keys.sort.each do |repo|
csv << [repo]
end
end
# All projects summed
return if res.count < 1
numeric_keys = []
res[0][2][:sum].keys.each do |key|
obj = res[0][2][:sum]
numeric_keys << key if obj[key].to_i.to_s == obj[key].to_s
end
numeric_keys -= %w(authors_alt1 authors_alt2)
sum_proj = {}
res.each do |proj|
numeric_keys.each do |key|
sum_proj[key] = 0 unless sum_proj.key?(key)
sum_proj[key] += proj[2][:sum][key].to_i
end
end
numeric_keys.each do |key1|
numeric_keys.each do |key2|
next if key1 == key2
key = "#{key1}/#{key2}"
sum_proj[key] = sum_proj[key2] == 0 ? Float::NAN : (sum_proj[key1].to_f / sum_proj[key2].to_f).round(4)
end
end
# Save all projects summed numeric values and their ratios
hdr = %w(key value)
CSV.open('reports/sumall.csv', "w", headers: hdr) do |csv|
csv << hdr
sum_proj.each do |key, value|
csv << [key, value]
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def project_ranking(title, table:, column:, scope: Project.for_display, direction: \"DESC\", description: nil)\n projects = scope.order(\"#{table}.#{column} #{direction} NULLS LAST\").limit(100)\n metrics = if table == :github_repos\n [\"github_repo_stargazers_count\", \"github_repo_#{column}\... | [
"0.6478451",
"0.6241944",
"0.6022876",
"0.59988904",
"0.5971307",
"0.5965575",
"0.58914155",
"0.58002204",
"0.57502145",
"0.5690036",
"0.56312954",
"0.5549773",
"0.5471608",
"0.5464966",
"0.54321057",
"0.5429995",
"0.53910595",
"0.5384678",
"0.5332854",
"0.532973",
"0.5312444... | 0.5451367 | 14 |
GET /signups or /signups.json | def index
@signups = Signup.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @sign_ups = SignUp.all\n end",
"def index\n @sign_ups = SignUp.all\n end",
"def index\n @signups = Signup.find(:all)\n\n respond_to do |format|\n format.html # index.html.erb\n end\n end",
"def show\n @signup = Signup.find(params[:id])\n\n respond_to do |format|\n ... | [
"0.6651045",
"0.6651045",
"0.6468852",
"0.636792",
"0.636792",
"0.6310774",
"0.62832594",
"0.6161588",
"0.6028819",
"0.5953405",
"0.5953405",
"0.57892996",
"0.5715291",
"0.56986594",
"0.5680118",
"0.5674533",
"0.5659528",
"0.56394285",
"0.56082237",
"0.5571724",
"0.5571724",
... | 0.66947293 | 0 |
GET /signups/1 or /signups/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show\n @signup = Signup.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @signup }\n end\n end",
"def show\n @signup = Signup.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { r... | [
"0.65736485",
"0.65736485",
"0.62666714",
"0.62138575",
"0.6173711",
"0.6173711",
"0.60778487",
"0.59562844",
"0.59562844",
"0.5882267",
"0.587573",
"0.5834907",
"0.58272254",
"0.57885784",
"0.5779647",
"0.57508653",
"0.57333124",
"0.5655631",
"0.5640743",
"0.56247514",
"0.55... | 0.0 | -1 |
POST /signups or /signups.json | def create
@seminar = Seminar.find(params[:seminar_id])
@signup = Signup.new(signup_params)
respond_to do |format|
if @signup.save
format.html { redirect_to @seminar, notice: "Signup was successfully created." }
format.json { render :show, status: :created, location: @seminar }
else
format.html { render :new, status: :unprocessable_entity }
format.json { render json: @signup.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def signup\n client.signup(\n params[:user],\n params[:password]\n )\n end",
"def signup(params={})\n begin\n JSON.parse(RestClient.put construct_url(\"user\"), params)\n rescue RestClient::BadRequest => e\n @last_error = e.http_body\n @last_error_code = e.http_code\n f... | [
"0.70315504",
"0.6896562",
"0.67104113",
"0.66593105",
"0.66593105",
"0.6553446",
"0.65303165",
"0.6527882",
"0.64776725",
"0.64760554",
"0.6454336",
"0.63894475",
"0.63790274",
"0.6377886",
"0.6359349",
"0.63152695",
"0.63019764",
"0.6294313",
"0.62606186",
"0.62086684",
"0.... | 0.6213503 | 19 |
PATCH/PUT /signups/1 or /signups/1.json | def update
respond_to do |format|
if @signup.update(signup_params)
format.html { redirect_to @signup, notice: "Signup was successfully updated." }
format.json { render :show, status: :ok, location: @signup }
else
format.html { render :edit, status: :unprocessable_entity }
format.json { render json: @signup.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n respond_to do |format|\n if @sign_up.update(sign_up_params)\n format.html { redirect_to @sign_up, notice: 'Sign up was successfully updated.' }\n format.json { render :show, status: :ok, location: @sign_up }\n else\n format.html { render :edit }\n format.json {... | [
"0.66260946",
"0.662606",
"0.6609775",
"0.65706855",
"0.6546377",
"0.6132547",
"0.6102531",
"0.5985001",
"0.5929003",
"0.5896646",
"0.5845322",
"0.58392084",
"0.58246666",
"0.5795066",
"0.57819253",
"0.57819253",
"0.5735923",
"0.5735923",
"0.57344526",
"0.56969714",
"0.568054... | 0.65493196 | 4 |
DELETE /signups/1 or /signups/1.json | def destroy
@signup.destroy
respond_to do |format|
format.html { redirect_to root_path, notice: "Signup was successfully destroyed." }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @signup = Signup.find(params[:id])\n @signup.destroy\n\n respond_to do |format|\n format.html { redirect_to signups_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @signup = Signup.find(params[:id])\n @signup.destroy\n\n respond_to do |format|\n fo... | [
"0.7457604",
"0.7437474",
"0.722599",
"0.7177149",
"0.7177149",
"0.7158465",
"0.70819557",
"0.7056483",
"0.68797505",
"0.6826592",
"0.6817438",
"0.6816306",
"0.65423644",
"0.6530778",
"0.64965177",
"0.64820826",
"0.6431135",
"0.6400997",
"0.6389141",
"0.6359121",
"0.6353047",... | 0.6995956 | 8 |
Use callbacks to share common setup or constraints between actions. | def set_signup
@signup = Signup.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_... | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576"... | 0.0 | -1 |
Only allow a list of trusted parameters through. | def signup_params
params.require(:signup).permit(:full_name, :attending, :user_id, :seminar_id)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def allowed_params\n ALLOWED_PARAMS\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def parameters_list_params\n params.require(:parameters_list).permit(:name, :description, :is_user_specific)\n end",
"def param_whitelist\n [:role, :title]\... | [
"0.69497335",
"0.6812623",
"0.6803639",
"0.6795365",
"0.67448795",
"0.67399913",
"0.6526815",
"0.6518771",
"0.64931697",
"0.6430388",
"0.6430388",
"0.6430388",
"0.63983387",
"0.6356042",
"0.63535863",
"0.63464934",
"0.63444513",
"0.6337208",
"0.6326454",
"0.6326454",
"0.63264... | 0.0 | -1 |
Normally we wouldn't nilhandle something whose presence we validate, but this accommodates stock new objects. | def time
start.try(:to_time).try(:strftime, '%-l:%M %P')
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validated?; end",
"def valid?; end",
"def valid?; end",
"def valid?; end",
"def valid?; end",
"def valid?; end",
"def valid?\n super && !object.nil?\n end",
"def validated; end",
"def validate_object(object)\n raise ActiveRecordObjectInvalid.new(\"The object is nil\") if object... | [
"0.68968624",
"0.67601454",
"0.67601454",
"0.67601454",
"0.67601454",
"0.67601454",
"0.6530996",
"0.6457986",
"0.64341193",
"0.6405989",
"0.63484585",
"0.6201515",
"0.61801004",
"0.6134039",
"0.609381",
"0.60596055",
"0.60596055",
"0.60596055",
"0.6030323",
"0.5997557",
"0.59... | 0.0 | -1 |
The row iterator. Calling this kicks off the actual query to the database server. Before triggering the enumerator, it rebuilds the dataset with the default traversal configured by the relation DSL. | def each(&iter)
# Configure the default traversal
unless @configured
@configured = true
self.class.traversal.each do |query_method, conditions|
@dataset = @dataset.send(query_method.to_sym, *conditions) if conditions
end
end
@dataset.each(&iter)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iterator\n @table.iterator\n end",
"def each_row\n @rows.each { |row| yield(row) }\n self\n end",
"def each_record\n return to_enum(:each_record) unless block_given?\n\n @relation.to_enum(:in_batches, of: @of, start: @start, finish: @finish, load: true).each do |relat... | [
"0.65767694",
"0.6419182",
"0.6391642",
"0.6381724",
"0.62319404",
"0.62319404",
"0.6208178",
"0.6168283",
"0.6147538",
"0.612838",
"0.60992587",
"0.60447806",
"0.6028038",
"0.6013364",
"0.6000629",
"0.59815854",
"0.5946532",
"0.59307265",
"0.59281605",
"0.59254444",
"0.59133... | 0.6954137 | 0 |
can add a word with or without definition | def add(word)
if word.class == String
word = {word => nil}
end
word.each do |key, value|
@entries[key] = value
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_word(word)\n \n end",
"def add_word(word)\r\n \r\n end",
"def add(word)\n end",
"def add_word(word, definition)\r\n @word << {Word: word, Definition: definition}\r\n # puts \"This is @word: #{@word}\"\r\n end",
"def add(word, w)\n if word != \"\" \... | [
"0.8024392",
"0.7796861",
"0.77204514",
"0.75243646",
"0.70271903",
"0.70127594",
"0.6995674",
"0.68465865",
"0.67729914",
"0.67504036",
"0.6656995",
"0.66289157",
"0.65388024",
"0.6534243",
"0.651296",
"0.6467197",
"0.64447165",
"0.6439278",
"0.6414103",
"0.6411269",
"0.6333... | 0.6455136 | 16 |
checks if keywords exist | def include?(key)
self.keywords.include?(key)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keyword_check(kw)\n unless (@keywords || %w(a is of has)).include?(kw)\n raise RDF::ReaderError, \"unqualified keyword '#{kw}' used without @keyword directive\" if validate?\n end\n end",
"def keyword_check(kw)\n unless (@keywords || %w(a is of has)).include?(kw)\n raise RDF::... | [
"0.7603658",
"0.75643045",
"0.7351358",
"0.73298955",
"0.7328528",
"0.7276235",
"0.71234167",
"0.7060567",
"0.7060567",
"0.7042437",
"0.70071614",
"0.6941253",
"0.69023347",
"0.678858",
"0.67314994",
"0.6715291",
"0.67134595",
"0.66937906",
"0.66928196",
"0.6659602",
"0.66582... | 0.7393272 | 2 |
finds using key prefix | def find(prefix)
found_entries = entries.select do |key, value|
key[0...prefix.length] == prefix
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find(prefix)\n prefix.downcase!\n @base.each_key do |name|\n if name.start_with? prefix\n puts base[name].to_s()\n end\n end\n end",
"def prefix_match(prefix)\n val = []\n database.each do |k, v|\n if k.downcase.start_with?(prefix)\n val.push(v)\n end\n en... | [
"0.81436497",
"0.77072823",
"0.74979776",
"0.7311308",
"0.6933936",
"0.6881843",
"0.68211997",
"0.6606908",
"0.6540081",
"0.65253985",
"0.6512746",
"0.64167684",
"0.6393237",
"0.6360908",
"0.6309606",
"0.63069755",
"0.62874556",
"0.6274689",
"0.6263691",
"0.62215537",
"0.6196... | 0.7978737 | 1 |
creates printable version of itself in AZ order | def printable
@entries.sort.map do |key, value|
"[#{key}] \"#{value}\""
end.join("\n")
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_s\n output_string = String.new\n letter_array = @spaces\n 4.times do\n output_string << letter_array.shift(4).join('') + \"\\n\"\n end\n output_string\n end",
"def to_s\n \t#Create an empty string\n \tletter_array = @spaces\n \t# puts letter_array.to_s\n \tletter_array.map!{|char| ch... | [
"0.6221788",
"0.60997695",
"0.60689783",
"0.60689783",
"0.6025666",
"0.6018155",
"0.5987579",
"0.5916537",
"0.5901646",
"0.5813651",
"0.57914144",
"0.57899845",
"0.57139903",
"0.5708603",
"0.5686002",
"0.56750643",
"0.56637937",
"0.5653396",
"0.56453377",
"0.56354696",
"0.561... | 0.5403132 | 51 |
this is private because user shouldnt be able to edit this method | def song_params #these are the parameters for someone inputting a new song
params.require(:song).permit(
:title, :release_year, :released, :genre, :artist_name
)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def private; end",
"def private_method\n end",
"def schubert; end",
"def suivre; end",
"def refutal()\n end",
"def who_we_are\r\n end",
"def probers; end",
"def custom; end",
"def custom; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def imple... | [
"0.80276555",
"0.7234487",
"0.7095275",
"0.70866865",
"0.6873054",
"0.6859121",
"0.6844074",
"0.6787706",
"0.6787706",
"0.67614853",
"0.67614853",
"0.67614853",
"0.67614853",
"0.67595816",
"0.67595816",
"0.67260146",
"0.6709329",
"0.6709329",
"0.6709329",
"0.6709329",
"0.6709... | 0.0 | -1 |
GET /load_balancer_checks/1 GET /load_balancer_checks/1.json | def show
@load_balancer_check = LoadBalancerCheck.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.json { render json: @load_balancer_check }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show\n @loadbalancer = Loadbalancer.find(params[:id])\n checkaccountobject(\"loadbalancers\",@loadbalancer)\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @loadbalancer }\n end\n end",
"def new\n @load_balancer_check = LoadBalancerCheck.new\n\n... | [
"0.71646255",
"0.68079233",
"0.67725056",
"0.6420092",
"0.6412188",
"0.6412188",
"0.6312722",
"0.62754285",
"0.62632596",
"0.62456673",
"0.6081912",
"0.60807294",
"0.60510445",
"0.60004306",
"0.5926501",
"0.5926501",
"0.59098774",
"0.5882282",
"0.5882282",
"0.5876644",
"0.584... | 0.7221235 | 0 |
GET /load_balancer_checks/new GET /load_balancer_checks/new.json | def new
@load_balancer_check = LoadBalancerCheck.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @load_balancer_check }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n @loadbalancer = Loadbalancer.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @loadbalancer }\n end\n end",
"def create\n @operations_check = OperationsCheck.find(params[:operations_check_id])\n @load_balancer_check = @operations_check.l... | [
"0.7520849",
"0.73086697",
"0.68148506",
"0.67844677",
"0.64767087",
"0.6375883",
"0.63088936",
"0.6306586",
"0.6220491",
"0.619944",
"0.60924894",
"0.60647595",
"0.60516846",
"0.6038595",
"0.5984123",
"0.59838283",
"0.5957461",
"0.59230953",
"0.59172744",
"0.59041506",
"0.58... | 0.8255936 | 0 |
POST /load_balancer_checks POST /load_balancer_checks.json | def create
@operations_check = OperationsCheck.find(params[:operations_check_id])
@load_balancer_check = @operations_check.load_balancer_checks.create(load_balancer_check_params)
respond_to do |format|
if @load_balancer_check.save
format.html { redirect_to operations_check_path(@operations_check, tab: "load_balancers"),
notice: 'Load balancer check was successfully created.' }
format.json { render json: @load_balancer_check, status: :created, location: @load_balancer_check }
else
format.html { redirect_to operations_check_path(@operations_check, tab: "load_balancers"),
notice: 'Commit failed - you must give a ticket number if the check failed!' }
format.json { render json: @load_balancer_check.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_balancer_check_params\n params.require(:load_balancer_check).permit(:name, :passed, :ticket)\n end",
"def load_balancer_data(balancer = nil)\n params = Smash.new(\"Action\" => \"DescribeLoadBalancers\")\n if balancer\n params[\"LoadBalancerNames.member.1\"] = balance... | [
"0.674266",
"0.6562776",
"0.65213484",
"0.6448973",
"0.63173854",
"0.6277968",
"0.60634625",
"0.6028632",
"0.60100573",
"0.60007507",
"0.5907815",
"0.575417",
"0.5738855",
"0.5731341",
"0.558941",
"0.55869645",
"0.55778813",
"0.5568571",
"0.5565897",
"0.55491614",
"0.55328256... | 0.726488 | 0 |
PATCH/PUT /load_balancer_checks/1 PATCH/PUT /load_balancer_checks/1.json | def update
@operations_check = OperationsCheck.find(params[:operations_check_id])
@load_balancer_check = @operations_check.load_balancer_checks.find(params[:id])
respond_to do |format|
if @load_balancer_check.update_attributes(load_balancer_check_params)
format.html { redirect_to @load_balancer_check, notice: 'Load balancer check was successfully updated.' }
format.json { head :no_content }
else
format.html { render action: "edit" }
format.json { render json: @load_balancer_check.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @loadbalancer = Loadbalancer.find(params[:id])\n checkaccountobject(\"loadbalancers\",@loadbalancer)\n respond_to do |format|\n if @loadbalancer.update_attributes(params[:loadbalancer])\n format.html { redirect_to @loadbalancer, notice: 'Loadbalancer was successfully updated.' }\n... | [
"0.7207094",
"0.61534846",
"0.60832393",
"0.60768056",
"0.5960794",
"0.59251094",
"0.59202045",
"0.5920056",
"0.59112555",
"0.58173275",
"0.5802535",
"0.5709812",
"0.56990373",
"0.56607133",
"0.56578153",
"0.5647831",
"0.561444",
"0.5515305",
"0.5464066",
"0.5414386",
"0.5402... | 0.7341003 | 0 |
DELETE /load_balancer_checks/1 DELETE /load_balancer_checks/1.json | def destroy
operations_check = OperationsCheck.find(params[:operations_check_id])
@load_balancer_check = LoadBalancerCheck.find(params[:id])
@load_balancer_check.destroy
respond_to do |format|
format.html { redirect_to operations_check_path(operations_check, tab: "load_balancers") }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @loadbalancer = Loadbalancer.find(params[:id])\n checkaccountobject(\"loadbalancers\",@loadbalancer)\n @loadbalancer.send_delete\n\n respond_to do |format|\n format.html { redirect_to loadbalancers_url }\n format.json { head :ok }\n end\n end",
"def delete\n client.... | [
"0.7664263",
"0.7411966",
"0.68069565",
"0.65915287",
"0.6584081",
"0.65492326",
"0.6354962",
"0.63073826",
"0.6193936",
"0.61193025",
"0.60942787",
"0.60919434",
"0.6067865",
"0.6040419",
"0.6016091",
"0.60158134",
"0.6002823",
"0.596039",
"0.59472096",
"0.5921339",
"0.58963... | 0.75157773 | 1 |
Use this method to whitelist the permissible parameters. Example: params.require(:person).permit(:name, :age) Also, you can specialize this method with peruser checking of permissible attributes. | def load_balancer_check_params
params.require(:load_balancer_check).permit(:name, :passed, :ticket)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def restricted_params\n #params.require(self.controller_name.classify.underscore.to_sym).permit([])\n raise(\"No strong params set, override restricted_params method in your controller. E.g. params.require(:model).permit(:attribute1, :attribute2)\")\n end",
"def strong_params\n params.require(:user).pe... | [
"0.7718344",
"0.7674626",
"0.75207216",
"0.7155158",
"0.7142339",
"0.7117573",
"0.7103159",
"0.70793116",
"0.7039148",
"0.70069605",
"0.70030576",
"0.7001473",
"0.7001473",
"0.69552064",
"0.69362193",
"0.6936087",
"0.6934291",
"0.6881009",
"0.6797773",
"0.6735618",
"0.6702711... | 0.0 | -1 |
New accounts created with an ID and an initial balance | def initialize(balance,account_open_date = Time.now)
@id = Random.rand(100000..999999)
@balance
@account_open_date = account_open_date
@minimum_balance = 0
@withdraw_fee = 0
check_opening_balance(balance)
show_current_balance
return @balance
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_balance\n if account_balance_id == nil\n account_amount = (self.net_price * self.quantity) * -1\n create_balance = AccountBalance.new(date: self.purchase.date, gl_account_id: self.gl_account_id, amount: account_amount, user_id: self.user_id)\n create_balance.save!\n self.account_balan... | [
"0.7519356",
"0.7374455",
"0.7374455",
"0.7132365",
"0.7060767",
"0.6981907",
"0.6882533",
"0.6877194",
"0.6775613",
"0.6754077",
"0.66658235",
"0.66397524",
"0.66285336",
"0.6621808",
"0.66155034",
"0.66155034",
"0.659763",
"0.6597454",
"0.65649205",
"0.65240085",
"0.6518498... | 0.64526534 | 25 |
deposit method accepts a single parameter: amount deposited method calls show_current_balance method, which returns updated account balance | def deposit(deposit_amount)
if deposit_amount <= 0
puts "dummy."
else
@balance += deposit_amount
end
show_current_balance
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deposit(deposit_amt = 0)\n @balance = @balance + deposit_amt\n return @balance\n end",
"def deposit(amount)\n @balance += amount\n puts \"Deposit #{amount}. New Balance: $#{@balance}\"\n returned\n end",
"def deposit(amount)\n @balance = @balance + amount\n end",
... | [
"0.83388793",
"0.8306262",
"0.82660514",
"0.8248467",
"0.8209155",
"0.8209122",
"0.8201388",
"0.8199799",
"0.8167533",
"0.8155764",
"0.8155764",
"0.8148469",
"0.8148469",
"0.8148373",
"0.8138851",
"0.81044495",
"0.81044495",
"0.81044495",
"0.81028414",
"0.8087366",
"0.8065709... | 0.83516705 | 0 |
withdraw method accepts a single parameter: money withdrawn method calls show_current_balance method, which returns updated account balance | def withdraw(withdraw_amount)
transaction = withdraw_amount + @withdraw_fee
if withdraw_amount <= 0
puts "dummy."
elsif @minimum_balance == (@balance - transaction)
# withdraw method does not allow account to be < minimum balance - Will output a warning message and return the original un-modified balance
puts "Warning: balance will be the minimum balance. I won't do that out of principle."
elsif @minimum_balance > (@balance - transaction)
# same thing here as above- balance cannot be less than minimum
puts "You trying to steal from me?? This is your warning!"
else
@balance -= (transaction)
end
show_current_balance
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def withdraw(amount_to_withdraw)\n @balance -= amount_to_withdraw\n end",
"def withdraw (amount, account)\n if account == \"checking\"\n @checking_account_balance -= amount\n elsif account == \"saving\"\n @saving_account_balance -= amount\n else\n puts \"No account was selected\"\n ... | [
"0.856358",
"0.82668024",
"0.8230991",
"0.8230991",
"0.8210265",
"0.8159266",
"0.81582826",
"0.8090796",
"0.80457574",
"0.80227363",
"0.79714507",
"0.79708123",
"0.7939538",
"0.7936278",
"0.78906214",
"0.7881213",
"0.7867185",
"0.7832754",
"0.77853453",
"0.7778172",
"0.775741... | 0.7782479 | 19 |
returns the account balance | def show_current_balance
return "Balance: $#{sprintf "%.2f", @balance}"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def account_balance\n response = execute_command('getbalance')\n parse_response(response)['Credit'].to_f\n end",
"def get_balance\n return balance\n end",
"def account_balance\n @account_balance\n end",
"def balance\n # accounts.reduce(0) {|sum, account| sum + account.balance}... | [
"0.9074151",
"0.8855496",
"0.8724153",
"0.85222673",
"0.85143226",
"0.8385574",
"0.8364143",
"0.8344455",
"0.82798964",
"0.82787615",
"0.827613",
"0.8254708",
"0.82247514",
"0.82092476",
"0.81868446",
"0.81751883",
"0.8172659",
"0.8154553",
"0.81530666",
"0.8129133",
"0.81192... | 0.0 | -1 |
Method is different than just withdrawing because it allows for an overdraft of $10, but still calls to the withdraw method | def withdraw_using_check(amount)
@minimum_balance = -10
if (@balance - amount - @withdraw_fee) >= @minimum_balance
@checks_used += 1
# user is allowed 3 free checks in a month; any subsequent use adds $2 fee
if @checks_used < 4
@withdraw_fee = 0
else
@withdraw_fee = 1
end
withdraw(amount)
@minimum_balance = 0 #reset the minimum_balance
else
puts "Sorry, that's beyond the overdraft allowance."
@minimum_balance = 0
end
show_current_balance
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def withdraw\n raise\n end",
"def withdraw(amount_to_withdraw)\n @balance -= amount_to_withdraw\n end",
"def draw; end",
"def draw; end",
"def draw\n raise \"Not implemented\"\n end",
"def withdraw\n copy self.class.withdraw(@id)\n true\n end",
"def withdraw\n cop... | [
"0.6936464",
"0.6554781",
"0.6396015",
"0.6396015",
"0.63607174",
"0.63334703",
"0.63334703",
"0.6326743",
"0.62702024",
"0.6225647",
"0.6225647",
"0.6225647",
"0.62072235",
"0.61878306",
"0.6187364",
"0.6153727",
"0.61461794",
"0.61461794",
"0.61456925",
"0.6114765",
"0.6108... | 0.0 | -1 |
resets number of checks used to 0 (at end of the month) | def reset_checks
@checks_used = 0
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset_checks\n @free_checks_available = FREE_CHECKS_PER_MONTH\n end",
"def reset_checks\n @check_count = 0\n end",
"def reset_checks\n @counter = 0\n end",
"def reset_checks\n @checks = 0\n end",
"def reset_checks\n @checks_remaining = 3\n end",
"def reset_checks\n... | [
"0.8185185",
"0.78533834",
"0.7710335",
"0.76588285",
"0.7296187",
"0.70789236",
"0.69958717",
"0.6554045",
"0.64842725",
"0.63339007",
"0.6280216",
"0.6119078",
"0.6046315",
"0.600885",
"0.5958528",
"0.5955705",
"0.5938101",
"0.5928935",
"0.5826641",
"0.580292",
"0.5775691",... | 0.75376445 | 4 |
Este es un setter | def instance_var=(value)
@instance_var = value
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set; end",
"def set; end",
"def __setter__\n \"#{self}=\"\n end",
"def setter\r\n @setter ||= Field.setter(@name)\r\n end",
"def attribute_to_set; end",
"def setter_method\n :\"#{self[:name]}=\"\n end",
"def _setter_method\n :\"_#{self[:name]}=\"\n en... | [
"0.7835655",
"0.7835655",
"0.78239405",
"0.75580305",
"0.74708915",
"0.74625117",
"0.74247646",
"0.73103386",
"0.7281559",
"0.7257858",
"0.70558745",
"0.69903",
"0.6958582",
"0.6937948",
"0.67910373",
"0.6767614",
"0.6714145",
"0.6688443",
"0.6669991",
"0.6660556",
"0.6644587... | 0.0 | -1 |
Simulation Display line = hash of line names to array of stops stations = hash of station names => hashes for each line => hash of trains at station OR hash for "passenger" => hash of passengers at station trains = hash of train names => hash of passengers | def displayState(lines,stations,trains)
lines.keys.sort.each { |color|
stops = lines[color]
puts color
stops.each { |stop|
pStr = ""
tStr = ""
stations[stop]["passenger"].keys.sort.each { |passenger|
pStr << passenger << " "
}
stations[stop][color].keys.sort.each { |trainNum|
tr = color+" "+trainNum
tStr << "[" << tr
if trains[tr] != nil
trains[tr].keys.sort.each { |p|
tStr << " " << p
}
end
tStr << "]"
}
printf(" %25s %10s %-10s\n", stop, pStr, tStr)
}
}
puts
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_stations_en_route\n\n start_station_sym = @start_station.gsub(\" \", \"_\").to_sym\n\n end_station_sym = @end_station.gsub(\" \", \"_\").to_sym\n\n start_line_sym = @start_line.to_sym\n\n end_line_sym = @end_line.to_sym\n \n if start_line_sym == :victoria\n start_line_sym_index = 0... | [
"0.70313203",
"0.70137686",
"0.68277156",
"0.6757647",
"0.6544579",
"0.6474797",
"0.6450042",
"0.6395969",
"0.63517505",
"0.6284855",
"0.62557924",
"0.62157595",
"0.6213245",
"0.6207116",
"0.61979896",
"0.6152699",
"0.6141164",
"0.61239606",
"0.60356426",
"0.6031895",
"0.6013... | 0.6936268 | 2 |
Example of how to use displayState | def displayExample
lines = { }
lines["Black"] = ["S1","S2"]
stations = {}
stations["S1"] = { }
stations["S2"] = { }
stations["S1"]["Black"] = { }
stations["S2"]["Black"] = { }
stations["S1"]["passenger"] = { }
stations["S2"]["passenger"] = { }
stations["S1"]["passenger"]["Jack"] = 0
stations["S2"]["passenger"]["John"] = 0
trains = { }
trains["Black 1"] = { }
trains["Black 1"]["Jim"] = 0
puts "Lines = " + lines.inspect
puts "Stations = " + stations.inspect
puts "Trains = " + trains.inspect
displayState(lines,stations,trains)
stations["S2"]["Black"]["1"] = 0
displayState(lines,stations,trains)
trains["Black 1"].delete("Jim")
stations["S2"]["passenger"]["Jim"] = 0
displayState(lines,stations,trains)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_state\n puts \"#{name} a #{life_points} points de vie !!\"\n end",
"def show_state\n puts \"#{@name} a #{@life_points} points de vie.\"\n end",
"def show_state\n puts \"#{@name} a #{@life_points} points de vie\"\n end",
"def show_state\n puts \"#{name} a #{life_points} points ... | [
"0.6797787",
"0.6792553",
"0.67549497",
"0.67539966",
"0.6750916",
"0.6743899",
"0.6730727",
"0.6728846",
"0.6710674",
"0.6701738",
"0.66994715",
"0.6686237",
"0.66603553",
"0.66438335",
"0.6637641",
"0.66361624",
"0.6601976",
"0.6586674",
"0.65197384",
"0.6457579",
"0.638038... | 0.0 | -1 |
Use callbacks to share common setup or constraints between actions. | def set_model_asset
@model_asset = ModelAsset.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_... | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576"... | 0.0 | -1 |
Only allow a trusted parameter "white list" through. | def model_asset_params
params.require(:model_asset).permit(:model_asset_name, type_asset_ids: [])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def allowed_params\n ALLOWED_PARAMS\n end",
"def expected_permitted_parameter_names; end",
"def param_whitelist\n [:role, :title]\n end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def permitted_params\n []\n end",
... | [
"0.7121987",
"0.70541996",
"0.69483954",
"0.6902367",
"0.6733912",
"0.6717838",
"0.6687021",
"0.6676254",
"0.66612333",
"0.6555296",
"0.6527056",
"0.6456324",
"0.6450841",
"0.6450127",
"0.6447226",
"0.6434961",
"0.64121825",
"0.64121825",
"0.63913447",
"0.63804525",
"0.638045... | 0.0 | -1 |
GET /positions/new GET /positions/new.xml | def new
@user = User.find(params[:user_id])
@position = @user.positions.build
@committees = Committee.all(:order => :code)
@roles = @committees.size > 0 ? @committees[0].roles : []
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @position }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n @position = Position.new\n \n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @position }\n end\n end",
"def new\n @position = Position.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @p... | [
"0.77458495",
"0.7739099",
"0.73096436",
"0.73096436",
"0.73096436",
"0.7039403",
"0.69023687",
"0.6855853",
"0.68451124",
"0.67869174",
"0.67222494",
"0.6680468",
"0.6677375",
"0.6644027",
"0.6632762",
"0.6602995",
"0.65693116",
"0.65235496",
"0.64933926",
"0.645674",
"0.645... | 0.60470575 | 56 |
POST /positions POST /positions.xml | def create
@user = User.find(params[:user_id])
@position = @user.positions.build(params[:position])
respond_to do |format|
if @position.save
flash[:notice] = 'Position was successfully created.'
format.html { redirect_to(@user) }
format.xml { render :xml => @position, :status => :created, :location => @position }
else
@committees = Committee.all(:order => :code)
@roles = []
if !params[:position][:committee_id].blank?
@roles = Role.all(:condition => ["committee_id = ?", params[:position][:committee_id]])
end
format.html { render :action => "new" }
format.xml { render :xml => @position.errors, :status => :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n respond_to do |format|\n if position.save\n format.html { redirect_to( position, flash: { success: 'Position created.' } ) }\n format.xml { render xml: position, status: :created, location: position }\n else\n format.html { render action: \"new\" }\n format.xm... | [
"0.69860995",
"0.6968086",
"0.6844047",
"0.66578025",
"0.66483974",
"0.6642075",
"0.66412973",
"0.66412973",
"0.6587157",
"0.6512084",
"0.6322979",
"0.63059",
"0.625105",
"0.6223546",
"0.61890554",
"0.6164848",
"0.61175",
"0.6078293",
"0.60696125",
"0.60637444",
"0.6058795",
... | 0.6184882 | 15 |
PUT /positions/1 PUT /positions/1.xml | def update
@position = Position.find(params[:id])
user = @position.user
respond_to do |format|
if @position.update_attributes(params[:position])
flash[:notice] = 'Position was successfully updated.'
format.html { redirect_to(user_path(user)) }
format.xml { head :ok }
else
@committees = Committee.all(:order => :code)
@roles = []
if !params[:position][:committee_id].blank?
@roles = Role.all(:condition => ["committee_id = ?", params[:position][:committee_id]])
end
format.html { render :action => "edit" }
format.xml { render :xml => @position.errors, :status => :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n respond_to do |format|\n if position.save\n format.html { redirect_to( position, flash: { success: 'Position updated.' } ) }\n format.xml { head :ok }\n else\n format.html { render action: \"edit\" }\n format.xml { render xml: position.errors, status: :unproc... | [
"0.6906585",
"0.6825522",
"0.6659861",
"0.6654162",
"0.65643275",
"0.6448095",
"0.6448095",
"0.6448095",
"0.636476",
"0.62846386",
"0.6237874",
"0.6171852",
"0.6140559",
"0.61304057",
"0.6073988",
"0.60664445",
"0.60014963",
"0.5947573",
"0.5942109",
"0.59374857",
"0.59246236... | 0.58526707 | 22 |
DELETE /positions/1 DELETE /positions/1.xml | def destroy
@position = Position.find(params[:id])
user = @position.user
@position.destroy
respond_to do |format|
format.html { redirect_to(user) }
format.xml { head :ok }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @position = Position.find(params[:id])\n @position.destroy\n \n respond_to do |format|\n format.html { redirect_to(positions_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @position = Position.find(params[:id])\n @position.destroy\n\n respond_to do... | [
"0.7353485",
"0.7325413",
"0.72275925",
"0.71173704",
"0.6888883",
"0.6859223",
"0.68506724",
"0.68235254",
"0.6811209",
"0.67841226",
"0.67627645",
"0.6712049",
"0.66962945",
"0.6673704",
"0.6535062",
"0.65343904",
"0.65343904",
"0.65343904",
"0.6495198",
"0.6487152",
"0.644... | 0.68318945 | 7 |
Returns an array of users instead of an Active Record relation | def all_friends
requested_friends + accepted_friends
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def users\n users_array = []\n if serialization_options[:include_users] == true\n # NOTE: object here refers to the ActiveRecord model object. self refers to the serializer object itself.\n object.users.each do |user|\n # NOTE: You can pass serialization_options t... | [
"0.79115945",
"0.7900494",
"0.7863669",
"0.76767874",
"0.7646934",
"0.7632329",
"0.75888306",
"0.7563246",
"0.7452662",
"0.7431003",
"0.7416045",
"0.74054694",
"0.73961896",
"0.73956007",
"0.7395328",
"0.7375119",
"0.736307",
"0.73128444",
"0.7296126",
"0.72954965",
"0.726519... | 0.0 | -1 |
GET /refunds/1 GET /refunds/1.json | def show
@refund = Refund.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.json { render json: @refund }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refunds\n RefundRepository.new(api).all(token)\n end",
"def index\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @refunds }\n end\n end",
"def refund(tid, refund)\n begin\n #creating url\n url = \"#{@s... | [
"0.7300918",
"0.7189426",
"0.71389496",
"0.71285766",
"0.7020494",
"0.7020494",
"0.6980948",
"0.69571817",
"0.69209987",
"0.6905681",
"0.6871181",
"0.6856648",
"0.6736021",
"0.66914386",
"0.6665205",
"0.66562665",
"0.66281515",
"0.66123986",
"0.6606755",
"0.6595409",
"0.65936... | 0.7494874 | 0 |
GET /refunds/new GET /refunds/new.json | def new
@refund = Refund.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @refund }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @refund = Refund.new(params[:refund])\n\n respond_to do |format|\n if @refund.save\n format.html { redirect_to @refund, notice: 'Refund was successfully created.' }\n format.json { render json: @refund, status: :created, location: @refund }\n else\n format.html { r... | [
"0.7760759",
"0.7684975",
"0.74572015",
"0.744348",
"0.6885683",
"0.6806962",
"0.6689645",
"0.66887814",
"0.6637615",
"0.65879345",
"0.6569617",
"0.6530977",
"0.65274894",
"0.65274894",
"0.65236926",
"0.6481491",
"0.64791125",
"0.64791125",
"0.6474597",
"0.6473745",
"0.646988... | 0.847749 | 0 |
POST /refunds POST /refunds.json | def create
@refund = Refund.new(params[:refund])
respond_to do |format|
if @refund.save
format.html { redirect_to @refund, notice: 'Refund was successfully created.' }
format.json { render json: @refund, status: :created, location: @refund }
else
format.html { render action: "new" }
format.json { render json: @refund.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refund(tid, refund)\n begin\n #creating url\n url = \"#{@security.environment}/transactions/#{tid}/refunds\"\n\n # make the request.\n json_response = Rede::CommonRequest::post(url, refund, @security)\n\n # mapping the result... | [
"0.72928524",
"0.72220093",
"0.7141533",
"0.7139806",
"0.70534503",
"0.6982286",
"0.69706225",
"0.6958251",
"0.6841389",
"0.6834011",
"0.6833234",
"0.68022853",
"0.68022853",
"0.677015",
"0.66018367",
"0.6594192",
"0.65577936",
"0.6523444",
"0.65152913",
"0.65089875",
"0.6508... | 0.7411639 | 0 |
PUT /refunds/1 PUT /refunds/1.json | def update
@refund = Refund.find(params[:id])
respond_to do |format|
if @refund.update_attributes(params[:refund])
format.html { redirect_to @refund, notice: 'Refund was successfully updated.' }
format.json { head :ok }
else
format.html { render action: "edit" }
format.json { render json: @refund.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @refund = Refund.find(params[:id])\n\n respond_to do |format|\n if @refund.update_attributes(params[:refund])\n format.html { redirect_to @refund, notice: 'Refund was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: ... | [
"0.75599337",
"0.7290829",
"0.70791286",
"0.70637393",
"0.6838148",
"0.68328863",
"0.68274236",
"0.6785931",
"0.6768365",
"0.6754151",
"0.6727216",
"0.6710479",
"0.66524756",
"0.662985",
"0.65941256",
"0.65941256",
"0.6587663",
"0.6534057",
"0.65168035",
"0.65012044",
"0.6469... | 0.75930625 | 0 |
DELETE /refunds/1 DELETE /refunds/1.json | def destroy
@refund = Refund.find(params[:id])
@refund.destroy
respond_to do |format|
format.html { redirect_to refunds_url }
format.json { head :ok }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @refund = Refund.find(params[:id])\n @refund.destroy\n\n respond_to do |format|\n format.html { redirect_to refunds_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @refund_request = RefundRequest.find(params[:id])\n @refund_request.destroy\n\n r... | [
"0.81307006",
"0.79905313",
"0.747926",
"0.71469235",
"0.6928885",
"0.67540485",
"0.6580265",
"0.6577861",
"0.6566604",
"0.65602875",
"0.65319526",
"0.6528937",
"0.64694643",
"0.6468193",
"0.6433934",
"0.6402421",
"0.63959885",
"0.63959885",
"0.639443",
"0.63930553",
"0.63847... | 0.8167571 | 0 |
ComparableVersion components comparison method. Uses Comparable to assess whether this ComparableVersion's component value or the other ComparableVersion's component value is greater or lesser. The first value to be found as greater or lesser determines which ComparableVersion object is greater or lesser. Missing ComparableVersion components are treated as 0 values, which effectively gives them no weight in the comparison. | def <=>(other)
NAMES.each do |name|
result = send(name).to_i <=> other.send(name).to_i
return result unless result.zero?
end
0
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def version_compare(a, b)\n make_comparable(a) <=> make_comparable(b)\n end",
"def <=>(other) \n\n versionComparison = Substring.new(get_version_string) <=> Substring.new(other.get_version_string)\n (return versionComparison) if versionComparison != 0\n\n other_pre = other.instance_var... | [
"0.75370085",
"0.73479027",
"0.7164859",
"0.70479125",
"0.69974416",
"0.69930375",
"0.6991202",
"0.6941551",
"0.68825054",
"0.68564",
"0.6855895",
"0.6848834",
"0.68362707",
"0.6833278",
"0.6831976",
"0.67892045",
"0.6777473",
"0.67425483",
"0.6643239",
"0.6628137",
"0.662465... | 0.0 | -1 |
For optional hooks and common install code see source_install cookbook | def config_creates_file(_new_resource)
return 'Makefile'
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pre_install; end",
"def post_install; end",
"def install\n end",
"def install\n end",
"def prepare_for_installation; end",
"def install\n \n end",
"def install\n end",
"def post_install\n end",
"def install_pre_hook\n end",
"def install\n # nothing to do\n end",
"def instal... | [
"0.806294",
"0.7675991",
"0.7613143",
"0.7613143",
"0.7577597",
"0.7533398",
"0.750301",
"0.7425259",
"0.7402049",
"0.7346697",
"0.7257728",
"0.7233837",
"0.7192863",
"0.7093575",
"0.7091394",
"0.7048891",
"0.704553",
"0.7033889",
"0.69562143",
"0.69073236",
"0.6856169",
"0... | 0.0 | -1 |
any key added gets this default value | def initialize(a_hash)
from_h(a_hash)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def default(key) end",
"def default key\n @defaults[String(key).to_sym]\n end",
"def default(key)\n @defaults[key]\n end",
"def default(key = nil) \n if key.is_a?(Symbol) && key?(key) \n self[key] \n else \n key ? super : super()\n end \n end",
"def defaul... | [
"0.8159272",
"0.75074995",
"0.7230401",
"0.72295016",
"0.72011006",
"0.70727634",
"0.70615983",
"0.6971565",
"0.69139403",
"0.69073707",
"0.6852512",
"0.68378747",
"0.68378747",
"0.68296564",
"0.67670673",
"0.67443347",
"0.6737938",
"0.67296857",
"0.65913683",
"0.6587792",
"0... | 0.0 | -1 |
Does this options instance have a specific key? | def has?(key)
respond_to? key
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def options_set?(key)\n @options.key? key\n end",
"def vash_valid_key?(x); self.class.option_name?(x); end",
"def option?(key)\n key = key&.to_sym\n @value.key?(key) || option_method(key).present?\n end",
"def has_key? k\n host_hash.has_key?(k) || options.has_key?(k)\n end... | [
"0.8427883",
"0.790109",
"0.78820586",
"0.77710575",
"0.7723696",
"0.76246333",
"0.7521684",
"0.75033665",
"0.7458805",
"0.7453645",
"0.74020773",
"0.7355702",
"0.73130935",
"0.7304248",
"0.73022795",
"0.72628987",
"0.72331744",
"0.71972287",
"0.7106662",
"0.7070685",
"0.7070... | 0.66688186 | 60 |
add some keys to this options instance uses instance_eval to define getter and setter for each key just like the attr_accessor does. | def add(*array_of_string_or_sym)
Array(array_of_string_or_sym).reject{|key| has?(key.to_s)}.each do |key|
instance_eval <<~EOM
def #{key}
@#{key}
end
def #{key}=(a_value)
@#{key} = a_value
end
EOM
send "#{key}=", DEFAULT # NOTE: instance varible not created until set
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_options! options = {}\n options.each_pair do |key, value| \n send(\"#{key}=\", value) if self.respond_to?(:\"#{key}=\")\n end \n end",
"def with(options)\n options.each do |key, value|\n begin\n send \"#{key}=\", value\n rescue NoMethodError\n ... | [
"0.66568255",
"0.6588515",
"0.6565643",
"0.65508395",
"0.64684343",
"0.64501137",
"0.63711125",
"0.63601774",
"0.6340328",
"0.6338312",
"0.626974",
"0.6268775",
"0.6257237",
"0.6252424",
"0.62206924",
"0.62024474",
"0.61933213",
"0.61906356",
"0.61779857",
"0.6162435",
"0.615... | 0.5726851 | 89 |
From an existing hash, add its keys and values to this options instance. | def from_h(a_hash)
a_hash.each_pair do |k, v|
add k
send("#{k}=", v)
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def options(hash)\n @options.merge! hash\n end",
"def options_from_hash(options_hash)\n options_hash.each do |name, definition|\n option = Option.new\n definition.each do |key, value|\n Array(value).each { |hit| option.send(key, hit) }\n end\n @@options << [name.to_s, option... | [
"0.74037474",
"0.73104227",
"0.71983457",
"0.7097878",
"0.68340844",
"0.665873",
"0.659494",
"0.65827876",
"0.6356206",
"0.63547957",
"0.6305396",
"0.6282437",
"0.6272234",
"0.62683105",
"0.6246634",
"0.61868995",
"0.61797696",
"0.6166319",
"0.6135071",
"0.6089134",
"0.608525... | 0.57319254 | 64 |
convert this options instance into a hash | def to_h
a_hash = Hash.new
keys = instance_variables.map{|var| var.to_s.gsub('@','')}
keys.each do |key|
a_hash[key] = send key
end
return a_hash
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_hash\n { @key => @options }\n end",
"def to_hash\n OPTIONS.inject({}) do |hash, option|\n hash[option.to_sym] = self.send(option)\n hash\n end\n end",
"def to_hash\n OPTIONS.inject({}) do |hash, option|\n hash[option.to_sym] = self.send(option)\n ... | [
"0.8403168",
"0.81027806",
"0.81027806",
"0.81027806",
"0.81027806",
"0.81027806",
"0.80515385",
"0.79956055",
"0.7946878",
"0.7946878",
"0.7922137",
"0.7832527",
"0.7832527",
"0.7832527",
"0.7832527",
"0.7607712",
"0.75960374",
"0.7520624",
"0.72703254",
"0.7230186",
"0.7177... | 0.0 | -1 |
Chapter 12 : New Classes of Objects Paty like it's roman_to_integer | def roman_to_integer(roman_value)
digital_vals = {'i'=> 1, 'v'=> 5, 'x'=> 10, 'l'=> 50,
'c'=> 100, 'd'=> 500, 'm'=> 1000,}
roman_value.each_char do |char|
if digital_vals.has_key?(char) == false
return "Invalid Entry!"
end
end
reversed_roman_value = roman_value.reverse
total_value = 0
prev_val = 0
prev_char = ''
reversed_roman_value.each_char do |char|
val = digital_vals[char]
val < prev_val ? val *= -1 : prev_val = val
total_value += val
=begin
Note: The commented method below isn't concise and simple as the current implementation
above.
Instead of comparing the alphabets, it's simpler to compare the values
case
when ((char == 'i') && (prev_char == 'x')) then total_value -= 1
when ((char == 'i') && (prev_char == 'v')) then total_value -= 1
when ((char == 'x') && (prev_char == 'l')) then total_value -= 10
when ((char == 'x') && (prev_char == 'c')) then total_value -= 10
when ((char == 'c') && (prev_char == 'd')) then total_value -= 100
when ((char == 'c') && (prev_char == 'm')) then total_value -= 100
else
total_value += digital_vals[char]
end
prev_char = char
=end
end
total_value
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_roman(num)\nend",
"def to_roman(num)\nend",
"def to_roman\n\n roman = ''\n\n roman = roman + 'M' * (self / 1000)\n roman = roman + 'D' * (self % 1000 / 500)\n roman = roman + 'C' * (self % 500 / 100)\n roman = roman + 'L' * (self % 100 / 50)\n roman = roman + 'X' * (self % 50 / 10)\n roman... | [
"0.77335984",
"0.77335984",
"0.73116595",
"0.7248213",
"0.7162003",
"0.71503675",
"0.7093005",
"0.7023124",
"0.7015381",
"0.70124257",
"0.6987278",
"0.6984734",
"0.6979771",
"0.69697434",
"0.6966342",
"0.69109327",
"0.69091445",
"0.68902487",
"0.6883052",
"0.6845945",
"0.6800... | 0.62525624 | 88 |
Execute a GraphQL query against the current schema. | def execute
render json: Schema.instance.execute(
params[:query],
variables: to_hash(params[:variables]),
context: context
)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_query(query)\n post_graphql(query, current_user: current_user)\n expect(graphql_errors).not_to be_present\n end",
"def execute(query)\n if validate_query\n validation = schema.validate(query)\n fail validation_error_message(validation) unless validation.valid?\n end\n\n ... | [
"0.6841076",
"0.6727782",
"0.65088147",
"0.6467917",
"0.64569646",
"0.64232177",
"0.62614805",
"0.62561643",
"0.6231172",
"0.6207018",
"0.61230594",
"0.59668523",
"0.59447813",
"0.5944272",
"0.592624",
"0.59181696",
"0.5894975",
"0.58848375",
"0.5872657",
"0.58332056",
"0.581... | 0.7178593 | 0 |
Public Method current_ballot Returns the last entered Ballot object, with associated Nominations and Voting Period included. Params: none Returns: The Member's last Ballot object. State Changes: none | def current_ballot
self.ballots.includes(:nominations, :voting_period).order(:created_at).last
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_current_bid\r\n self.get_current_ranking\r\n if self.bid.empty?\r\n return 0\r\n else\r\n return bid.last.value\r\n end\r\n end",
"def current_budget\n Budget.where(user_id: current_user.id).sort_by(&:created_at).last\n end",
"def current_wallet\n # currency_... | [
"0.64466846",
"0.64337814",
"0.6287035",
"0.60638887",
"0.60304683",
"0.59815466",
"0.59167403",
"0.57930803",
"0.57761276",
"0.5706055",
"0.5683411",
"0.56265193",
"0.56242883",
"0.5623599",
"0.55644333",
"0.5554674",
"0.55306304",
"0.55306304",
"0.5512453",
"0.54998565",
"0... | 0.8227299 | 0 |
action about GET /about/me | def about_me
@breadcrumbs << [I18n.t('pages.about.breadcrumb'), about_path]
@breadcrumbs << [I18n.t('pages.about.me.breadcrumb')]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_about_me\n @about_me = AboutMe.find(params[:id])\n end",
"def about\n\n end",
"def me\n get(\"/me\")\n end",
"def about\n\n end",
"def about\n\n end",
"def about\n\n end",
"def about\r\n end",
"def about\n\t\t@user = current_user\n\tend",
"def about\n end",
"def ... | [
"0.73857296",
"0.72190195",
"0.71985734",
"0.7183703",
"0.7183703",
"0.7183703",
"0.7177676",
"0.7174927",
"0.71555734",
"0.7132817",
"0.7132817",
"0.7132817",
"0.7132817",
"0.7132817",
"0.7132817",
"0.7132817",
"0.7132817",
"0.7132817",
"0.7132817",
"0.7132817",
"0.7132817",... | 0.6503356 | 57 |
action about_me GET / | def index
@breadcrumbs = nil
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def me\n get(\"/me\")\n end",
"def about; render; end",
"def about_me\n\tend",
"def about\r\n end",
"def about\n\tend",
"def about\n\tend",
"def about\n\n end",
"def about\n end",
"def about\n\n end",
"def about\n\n end",
"def about\n\n end",
"def about\n end",
"def about... | [
"0.73576516",
"0.73196125",
"0.7315253",
"0.72971904",
"0.7225918",
"0.7225918",
"0.72192425",
"0.721177",
"0.7176801",
"0.7176801",
"0.7176801",
"0.71749026",
"0.71749026",
"0.71749026",
"0.71749026",
"0.71749026",
"0.71749026",
"0.71749026",
"0.71749026",
"0.71749026",
"0.7... | 0.0 | -1 |
It will print nothing. It returned a proc object. 3. Exception handling allows you to continue processing a block of code even though you may get an error. 4. | def execute(&block)
block.call
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def proc_return\n my_proc = Proc.new { return }\n my_proc.call\n puts \"This will not be printed\"\nend",
"def test1\n p = Proc.new { return }\n p.call\n puts “This line can’t display”\nend",
"def proc_demo_method\n proc_demo = Proc.new { return \"Only I print!\" }\n proc_demo.call\n \"But what ... | [
"0.71510273",
"0.70634013",
"0.70488673",
"0.67264813",
"0.6707662",
"0.66209525",
"0.65946037",
"0.65925366",
"0.6588825",
"0.6583525",
"0.65781486",
"0.65026164",
"0.649107",
"0.6457364",
"0.63953876",
"0.63888377",
"0.63551354",
"0.6349233",
"0.633998",
"0.6305974",
"0.628... | 0.0 | -1 |
I needed a way to pass resume items to the view if and only if that resume item applied to that particular user. So only show advanced_degree_uni for users w/ advanced degrees. I got impatient and wrote code that repeated a lot :( Just wanted to hurry and get it done. options method is intended to produce matches in the same profession but with the opposite expertise so experts and beginners are paired. | def options
@my_career_id = current_user.career_id
@match = []
@peers = []
@same_career = User.where(:career_id => @my_career_id)
@same_career.each do |match| #This can be written with match.expertise != current_user.expertise but I'm anticipating adding more expertise options so I wrote it in a way where I can easily encorporate those later.
if current_user.expertise == "Beginner"
if match.expertise == "Expert" # NOTICE!!! Written this way in anticipation of adding more expertise options (Proficient, Masterful, Mid-level etc.)
@match.push(match.id)
elsif match.expertise =="Beginner"
@peers.push(match.id)
end
elsif current_user.expertise == "Expert"
if match.expertise == "Expert"
@peers.push(match.id)
elsif match.expertise == "Beginner"
@match.push(match.id)
end
end
end
return @match[0..10] #first 11 matches User id's returned by this method
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resumes_offered\n\t @resumes = ReqMatch.where(:status => \"OFFERED\")\n\t\trender \"resumes/offered\"\n\tend",
"def index\n @resume_recomendations = ResumeRecomendation.where(resume: params[:resume]).first\n end",
"def show\n if User.find(session[:user_id]).access == \"teacher\"\n redirect_to ... | [
"0.59650975",
"0.59599316",
"0.5911656",
"0.58913064",
"0.5830602",
"0.5791131",
"0.57712024",
"0.57487434",
"0.5707192",
"0.57059234",
"0.56891465",
"0.56610155",
"0.56574833",
"0.5653824",
"0.5635772",
"0.5633876",
"0.5613858",
"0.5592393",
"0.5581049",
"0.55447894",
"0.554... | 0.65157384 | 0 |
The choosen method checks to see if anyone else has choosen you as a potential mentor/mentee | def choosen
@pair = []
for pair in @pair_collection do
if pair.mentee_id == current_user.id
@pair.push(pair.user_id)
end
end
return @pair
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def chosen(already, owner, other)\n\t\tif already && already.owner_id == owner.id && current_user\n\t\t\t\"chosen\"\n\t\telse\n\t\t\tother\n\t\tend\n\tend",
"def agreed\n @choosen = []\n @my_mentees = Pair.find_by_user_id(current_user.id).mentee_id\n if @my_mentees.is_a?(Integer)\n if Pair.find_by_... | [
"0.7301292",
"0.7024099",
"0.63019735",
"0.6154381",
"0.613826",
"0.6008028",
"0.59964246",
"0.5967801",
"0.59605116",
"0.59596354",
"0.5880842",
"0.58175373",
"0.5804123",
"0.5726095",
"0.5720973",
"0.5720038",
"0.5718505",
"0.5703853",
"0.56959254",
"0.56904674",
"0.5673616... | 0.5918908 | 10 |
This method finds users who have agreed upon a mentor mentee relationship | def agreed
@choosen = []
@my_mentees = Pair.find_by_user_id(current_user.id).mentee_id
if @my_mentees.is_a?(Integer)
if Pair.find_by_user_id(@my_mentees) != nil
@my_mentees_choice = Pair.find_by_user_id(@my_mentees).mentee_id
if @my_mentees_choice == current_user.id
@choosen.push(@my_mentees)
end
end
else
@my_mentees.each do |mentee|
@mentees_matches = Pair.find_by_user_id(mentee).mentee_id
if @mentees_matches.is_a?(Integer)
if @mentees_matches == current_user.id
@choosen.push(@mentees_matches)
end
elsif @mentees_matches != nil
@mentees_matches.each do |me|
if me == current_user.id
@choosen.push(me)
end
end
end
end
end
return @choosen.last
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mutual_mentions\n mentions.select do |mentioned_user|\n mentioned_user.mentioned?(self)\n end\n end",
"def followee?(other_user)\n followee_relationships.include?(other_user)\n end",
"def owner_as_well_as_all_mentioned_users_and_artists_except(user_or_artist_id, user = true)\n pa... | [
"0.65056205",
"0.61970526",
"0.612537",
"0.60936016",
"0.5927651",
"0.5911463",
"0.58934766",
"0.58827215",
"0.5870918",
"0.58705455",
"0.5860973",
"0.5821312",
"0.5821084",
"0.5777066",
"0.57762784",
"0.57731783",
"0.57656527",
"0.57648414",
"0.5762694",
"0.5753903",
"0.5752... | 0.54840004 | 61 |
Return the total number of characters Use recursion | def character_count(array)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_chars (foo)\n foo.length\n end",
"def count_chars (string)\n string.length\nend",
"def number_of_characters\n @text.length\n end",
"def number_of_chars\n text.to_s.number_of_chars\n end",
"def count_chars(word)\n word.length\nend",
"def count_chars(word)\n word.length... | [
"0.764118",
"0.76155484",
"0.73002905",
"0.72907305",
"0.7285102",
"0.7285102",
"0.7285102",
"0.7285102",
"0.7277611",
"0.7277611",
"0.7277611",
"0.7277611",
"0.72259545",
"0.72018945",
"0.71919966",
"0.6982294",
"0.68677896",
"0.682319",
"0.6798771",
"0.6749782",
"0.6714177"... | 0.69057226 | 16 |
GET /bookings GET /bookings.json | def index
tour_creator = Tour.find_by(tourname: session[:tourname])
#Agent who created the tour
if session[:role]==2 and session[:username] == tour_creator.username
@bookings=Booking.where(tourname: session[:tourname])
#Customer
elsif session[:role]==1
@bookings=Booking.where(username: session[:username])
#Admin
elsif session[:role]==3
@bookings=Booking.all
#Other agents
else
respond_to do |format|
format.html { redirect_to tours_url, notice: 'Agents can view bookings only of tours created by them' }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @bookings = Booking.all\n\n render json: @bookings\n end",
"def index\n @bookings = Booking.all\n\n respond_to do |format|\n format.html\n format.json { render :json => @bookings }\n end\n end",
"def index\n @bookings = Booking.all\n\n respond_to do |format|\n ... | [
"0.8231102",
"0.80365145",
"0.80220497",
"0.80220497",
"0.80220497",
"0.7619097",
"0.7607287",
"0.7501954",
"0.7473071",
"0.7473071",
"0.7473071",
"0.7473071",
"0.7473071",
"0.7473071",
"0.7473071",
"0.7473071",
"0.7473071",
"0.7473071",
"0.7473071",
"0.7473071",
"0.7473071",... | 0.0 | -1 |
GET /bookings/1 GET /bookings/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @bookings = Booking.all\n\n render json: @bookings\n end",
"def index\n @bookings = Booking.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @bookings }\n end\n end",
"def index\n @bookings = Booking.all\n\n respond_to do |f... | [
"0.7793375",
"0.76496434",
"0.76496434",
"0.76496434",
"0.76409495",
"0.76042414",
"0.75729305",
"0.73645985",
"0.73645985",
"0.73645985",
"0.73645985",
"0.7241474",
"0.7206953",
"0.7206953",
"0.7206953",
"0.7206953",
"0.7206953",
"0.7206953",
"0.7206953",
"0.7206953",
"0.720... | 0.0 | -1 |
POST /bookings POST /bookings.json | def create
option=booking_params[:mode_of_booking].to_i
@booking = Booking.new(booking_params.except(:mode_of_booking).merge(:username => session[:username], :tourname => session[:tourname], :user_id => session[:user_id], :tour_id => session[:tour_id]))
if session[:role] != 2
respond_to do |format|
mode,booked,waitlisted = @booking.bookmytour(option,session)
if mode == 0
format.html { redirect_to @booking, notice: 'Booking was successfully created.' }
format.json { render :show, status: :created, location: @booking }
elsif mode == 1
format.html { redirect_to @booking, notice: "You have booked #{booked} seats" }
format.json { render :show, status: :created, location: @booking }
elsif mode == 2
format.html { redirect_to @booking, notice: "You have booked #{booked} seats and are waitlisted for #{waitlisted} seats" }
format.json { render :show, status: :created, location: @booking }
elsif mode == 3
format.html { redirect_to @booking, notice: "You have been waitlisted for #{waitlisted} seats" }
format.json { render :show, status: :created, location: @booking }
else
format.html { redirect_to new_booking_url, notice: 'Required number of seats unavailable' }
format.json { render :show, status: :created, location: @booking }
end
end
else
redirect_to new_booking_url, notice:"Only customer can book a tour"
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n booking = Booking.create(booking_params)\n render json: booking\n end",
"def create\n\t\tbooking = Booking.new(booking_params)\n\n\t if booking.save\n\t \tPeekBooker.use_a_boat(booking.size, booking.timeslot_id)\n\t \tPeekBooker.delete_overlap_assignments(booking.timeslot_i... | [
"0.7353111",
"0.7228384",
"0.68615675",
"0.6782987",
"0.6782987",
"0.67671645",
"0.6642527",
"0.66402507",
"0.6624695",
"0.65151906",
"0.6509862",
"0.6509862",
"0.6509862",
"0.64893967",
"0.6432859",
"0.6378296",
"0.634707",
"0.63245595",
"0.6297444",
"0.62888706",
"0.6278033... | 0.0 | -1 |
PATCH/PUT /bookings/1 PATCH/PUT /bookings/1.json | def update
respond_to do |format|
if @booking.update(booking_params.except(:mode_of_booking))
format.html { redirect_to @booking, notice: 'Booking was successfully updated.' }
format.json { render :show, status: :ok, location: @booking }
else
format.html { render :edit }
format.json { render json: @booking.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @booking = Booking.find(params[:id])\n\n if @booking.update(booking_params)\n head :no_content\n else\n render json: @booking.errors, status: :unprocessable_entity\n end\n end",
"def update\n @booking = Booking.find(params[:id])\n @booking.update_attributes(params[:booki... | [
"0.70660025",
"0.7035505",
"0.6951961",
"0.69296867",
"0.69296867",
"0.69296867",
"0.6925516",
"0.68727815",
"0.67891777",
"0.6737531",
"0.67097384",
"0.66938263",
"0.66938263",
"0.66938263",
"0.66782904",
"0.66559863",
"0.66393423",
"0.66337067",
"0.6626812",
"0.6624749",
"0... | 0.64761007 | 58 |
DELETE /bookings/1 DELETE /bookings/1.json | def destroy
booking_creator = Booking.find_by(id: params[:id])
if session[:role] == 3 or booking_creator.user_id == session[:user_id]
@booking.cancelBooking(session)
@booking.destroy
respond_to do |format|
format.html { redirect_to bookings_url, notice: 'Booking was successfully destroyed.' }
format.json { head :no_content }
end
else
respond_to do |format|
format.html { redirect_to bookings_url, notice: 'Booking can only be cancelled by their creators' }
format.json { head :no_content }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @booking = Booking.find(params[:id])\n @booking.destroy\n\n respond_to do |format|\n format.html { redirect_to bookings_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @booking = Booking.find(params[:id])\n @booking.destroy\n\n respond_to do |fo... | [
"0.7660707",
"0.7660707",
"0.7660707",
"0.7660707",
"0.7657568",
"0.7565737",
"0.75498253",
"0.75498253",
"0.739592",
"0.7359668",
"0.7359668",
"0.729106",
"0.72711414",
"0.724865",
"0.724865",
"0.724865",
"0.724865",
"0.724865",
"0.724865",
"0.724865",
"0.724865",
"0.72486... | 0.0 | -1 |
Use callbacks to share common setup or constraints between actions. | def set_booking
@booking = Booking.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_... | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576"... | 0.0 | -1 |
Never trust parameters from the scary internet, only allow the white list through. | def booking_params
params.require(:booking).permit(:status, :seatsToBook, :username, :tourname, :user_id, :tour_id, :mode_of_booking)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n... | [
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",... | 0.0 | -1 |
Check that a tableless VALUES(xxx) query (like SELECT works. | def test_values
value = nil
assert_nothing_raised do
value = ActiveRecord::Base.connection.send(:select_rows, "VALUES('ur', 'doin', 'it', 'right')")
end
assert_equal [['ur', 'doin', 'it', 'right']], value
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select_values_sql(sql)\n sql << \"VALUES \"\n expression_list_append(sql, opts[:values])\n end",
"def check_duplicate_item(db, tbl,field_name,value)\r\n check_command = \"Select * from ? where ? = ?\",[tbl, field_name,value]\r\n if db.execute(check_command).length > 0\r\n return true\... | [
"0.59113854",
"0.56363773",
"0.557994",
"0.5515803",
"0.54231274",
"0.5422416",
"0.5396056",
"0.5377148",
"0.53701967",
"0.5317282",
"0.5289754",
"0.5259012",
"0.52416015",
"0.52325904",
"0.5231039",
"0.52114344",
"0.52033466",
"0.5185567",
"0.51726",
"0.5171867",
"0.5171867"... | 0.7062435 | 0 |
Modify methods, public_methods and respond_to?, because method_missing allows methods from the analyser | def methods(*args)
(super + analyser.delegatable_methods).uniq
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def respond_to_missing?(_method, _include_private = false)\n true\n end",
"def respond_to_missing?(_method_name, _include_private = T.unsafe(nil)); end",
"def respond_to_missing?( method, include_private = false )\n super || (method.to_s =~ METHOD_NAME_REGEXP ) || true\n end",
"def respon... | [
"0.7390575",
"0.7309343",
"0.7299983",
"0.72948635",
"0.7293679",
"0.72893405",
"0.72817755",
"0.72817755",
"0.72638476",
"0.7233463",
"0.7205749",
"0.72008175",
"0.7133208",
"0.710953",
"0.7047295",
"0.70109755",
"0.7007806",
"0.6992882",
"0.698629",
"0.69750893",
"0.6969794... | 0.0 | -1 |
Use callbacks to share common setup or constraints between actions. | def set_post
@post = Post.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_... | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576"... | 0.0 | -1 |
Never trust parameters from the scary internet, only allow the white list through. | def post_params
params.require(:post).permit(:title, :body)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n... | [
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",... | 0.0 | -1 |
Use callbacks to share common setup or constraints between actions. | def set_returnbook
@returnbook = Returnbook.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_... | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576"... | 0.0 | -1 |
Only allow a trusted parameter "white list" through. | def returnbook_params
params.require(:returnbook).permit(:name)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def allowed_params\n ALLOWED_PARAMS\n end",
"def expected_permitted_parameter_names; end",
"def param_whitelist\n [:role, :title]\n end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def permitted_params\n []\n end",
... | [
"0.7121987",
"0.70541996",
"0.69483954",
"0.6902367",
"0.6733912",
"0.6717838",
"0.6687021",
"0.6676254",
"0.66612333",
"0.6555296",
"0.6527056",
"0.6456324",
"0.6450841",
"0.6450127",
"0.6447226",
"0.6434961",
"0.64121825",
"0.64121825",
"0.63913447",
"0.63804525",
"0.638045... | 0.0 | -1 |
GET /kinships GET /kinships.json | def index
@kinships = Kinship.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @clientships = current_user.clientships.all \n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @clientships }\n end\n end",
"def show\n @clientship = current_user.clientships.find(params[:id]) \n\n respond_to do |format|\n form... | [
"0.6735714",
"0.6403946",
"0.6397765",
"0.6390696",
"0.6390696",
"0.62893146",
"0.623615",
"0.60142434",
"0.59776074",
"0.5894923",
"0.58757216",
"0.5874103",
"0.5869684",
"0.5861144",
"0.58589584",
"0.58061296",
"0.5777648",
"0.57583886",
"0.5751566",
"0.57497543",
"0.573626... | 0.7663257 | 0 |
GET /kinships/1 GET /kinships/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @kinships = Kinship.all\n end",
"def show\n @clientship = current_user.clientships.find(params[:id]) \n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @clientship }\n end\n end",
"def index\n @clientships = current_user.clientships.... | [
"0.7289876",
"0.6744972",
"0.6678824",
"0.65339464",
"0.65339464",
"0.640773",
"0.6334629",
"0.63059735",
"0.62979287",
"0.6200103",
"0.6185519",
"0.6098511",
"0.607606",
"0.60554427",
"0.60470307",
"0.60356027",
"0.6019189",
"0.60183597",
"0.6000798",
"0.5885728",
"0.5881674... | 0.0 | -1 |
POST /kinships POST /kinships.json | def create
@kinship = Kinship.new(kinship_params)
@article = @kinship.article
respond_to do |format|
if @kinship.save
format.html { redirect_to @kinship, notice: 'Kinship was successfully created.' }
format.json { render :show, status: :created, location: @kinship }
format.js
else
format.html { render :new }
format.json { render json: @kinship.errors, status: :unprocessable_entity }
format.js
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kinship_params\n params.require(:kinship).permit(:user_id, :kin_id, :article_relation_type_id, :article_id)\n end",
"def set_kinship\n @kinship = Kinship.find(params[:id])\n end",
"def index\n @kinships = Kinship.all\n end",
"def ship_params\n params.require(:ship).permit(:name, ... | [
"0.65937465",
"0.63844264",
"0.63649267",
"0.60543674",
"0.595679",
"0.5896836",
"0.5855277",
"0.5842842",
"0.58414316",
"0.58269876",
"0.5818037",
"0.5805796",
"0.5780632",
"0.573651",
"0.5689578",
"0.5613494",
"0.56023616",
"0.55910724",
"0.5566083",
"0.5525964",
"0.5525392... | 0.61184555 | 3 |
PATCH/PUT /kinships/1 PATCH/PUT /kinships/1.json | def update
respond_to do |format|
if @kinship.update(kinship_params)
format.html { redirect_to @kinship, notice: 'Kinship was successfully updated.' }
format.json { render :show, status: :ok, location: @kinship }
else
format.html { render :edit }
format.json { render json: @kinship.errors, status: :unprocessable_entity }
format.js
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @clientship = current_user.clientships.find(params[:id])\n\n respond_to do |format|\n if @clientship.update_attributes(params[:clientship])\n format.html { redirect_to @clientship, notice: 'Clientship was successfully updated.' }\n format.json { head :ok }\n else\n ... | [
"0.68124956",
"0.66144836",
"0.66109496",
"0.65965223",
"0.6299792",
"0.6238834",
"0.6238834",
"0.6215682",
"0.6210581",
"0.6191905",
"0.6191905",
"0.6190379",
"0.61720306",
"0.61492085",
"0.6111567",
"0.6107306",
"0.6105675",
"0.60923207",
"0.60282284",
"0.599477",
"0.599073... | 0.6711181 | 1 |
DELETE /kinships/1 DELETE /kinships/1.json | def destroy
@article = @kinship.article
@kinship.destroy
respond_to do |format|
format.html { redirect_to kinships_url, notice: 'Kinship was successfully destroyed.' }
format.json { head :no_content }
format.js
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @clientship = current_user.clientships.find(params[:id])\n @clientship.destroy\n\n respond_to do |format|\n format.html { redirect_to clientships_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @ship = Ship.find(params[:id])\n @ship.destroy\n\n respond_... | [
"0.73626494",
"0.7163296",
"0.7163296",
"0.7141485",
"0.7096264",
"0.7091834",
"0.6990462",
"0.6990462",
"0.6990462",
"0.69900554",
"0.6959339",
"0.6896366",
"0.6892532",
"0.6762323",
"0.67380893",
"0.6725611",
"0.67218405",
"0.67100304",
"0.669493",
"0.66756713",
"0.6675378"... | 0.6220584 | 56 |
Use callbacks to share common setup or constraints between actions. | def set_kinship
@kinship = Kinship.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_... | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576"... | 0.0 | -1 |
Never trust parameters from the scary internet, only allow the white list through. | def kinship_params
params.require(:kinship).permit(:user_id, :kin_id, :article_relation_type_id, :article_id)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n... | [
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",... | 0.0 | -1 |
Initialize a new VersionCheck instance | def initialize(version, constraint)
@version = Gem::Version.new(version)
@match = PATTERN.match(constraint.to_s)
raise ArgumentError, "A version (eg. 5.0) is required to compare against" unless @version
raise ArgumentError, "At least one operator and version is required (eg. >= 5.1)" unless constraint
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(version_requirement:)\n self.version_verifier_strategy_factory = ::Kitchen::Terraform::VersionVerifierStrategyFactory.new(\n version_requirement: version_requirement,\n )\n end",
"def initialize(check, severity, message)\n @check = check\n @severity = severity\n ... | [
"0.68008065",
"0.67218333",
"0.66921747",
"0.6563834",
"0.65204185",
"0.6504364",
"0.6421279",
"0.6311321",
"0.62593997",
"0.6244521",
"0.61982346",
"0.61332285",
"0.6089926",
"0.60759676",
"0.60759676",
"0.60730106",
"0.6072783",
"0.5982927",
"0.5966857",
"0.5959745",
"0.595... | 0.55825365 | 65 |
Checks if all constraints were met | def satisfied?
constraints.all? do |expected, operator|
compare(expected, operator)
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_valid\n # Check the vertical\n @size.times { |i|\n if !valid_column(i)\n return false\n end\n }\n\n # Check the diagonal\n @size.times { |i|\n if !valid_diagonal(true, true, i)\n return false\n end\n if !valid_diagonal(true, false, i)\n return fa... | [
"0.68792605",
"0.67158866",
"0.66993773",
"0.63204634",
"0.62517905",
"0.6230455",
"0.6210362",
"0.61854947",
"0.61657786",
"0.61072147",
"0.6080147",
"0.60613644",
"0.6042034",
"0.60166115",
"0.59950644",
"0.5951607",
"0.59254044",
"0.59219205",
"0.5920516",
"0.5920516",
"0.... | 0.66374356 | 3 |
account list table view | def numberOfRowsInTableView(sender)
accounts.size
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_account_table(accounts, options={})\r\n opts = {show_checkbox_for_row: true}.merge(options)\r\n\r\n if session[:display_all]\r\n # custom text renderer for the password.\r\n opts.merge!({custom_text_renderers: {password: lambda(&method(:decrypt_password))}})\r\n\r\n # Alternatively,... | [
"0.7055214",
"0.7002373",
"0.6853729",
"0.68044156",
"0.68044156",
"0.68044156",
"0.68044156",
"0.68044156",
"0.68044156",
"0.68044156",
"0.68044156",
"0.68044156",
"0.68044156",
"0.68042314",
"0.6799865",
"0.67894",
"0.67537266",
"0.6740288",
"0.67249024",
"0.67249024",
"0.6... | 0.6471737 | 31 |
Beats per minute. Function: Code block that accomplishes a specific task. Descriptive name! Longer names (_ instead of spaces). 4/4 rhythm. | def four_four
sample :drum_heavy_kick
sleep 1
sample :drum_snare_hard
sleep 1
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_duration_of(task) ; 5 ; end",
"def tempo(beats_per_second)\n\t\tbeats_per_minute = beats_per_second * 60 \n\tend",
"def tock\n @minute += 1\n end",
"def bake(minutes)\n \"Baking the cookie in #{minutes} mins.\"\n end",
"def work(interval = 5.0)\n end",
"def test_120_tasks_every_s... | [
"0.6548734",
"0.64426374",
"0.63719594",
"0.6168533",
"0.6072929",
"0.6061085",
"0.5943128",
"0.5899494",
"0.5788908",
"0.5749816",
"0.5727428",
"0.57154983",
"0.57017165",
"0.57017165",
"0.5696604",
"0.5695753",
"0.56887335",
"0.5684847",
"0.56658494",
"0.5659759",
"0.565673... | 0.0 | -1 |
CITE : DESC : Showed a better way of organizing the melody! | def alejandro1
# Variable creation.
# Data structure (way of storing data): List
notes = [:b4, :b4, :b4, :d4, :e4, :fs4, :fs4, :e4,
:fs4, :fs4, :fs4, :c4, :c4, :c4, :c4] # :r is rest.
durations = [0.5, 0.25, 0.25, 0.5, 0.5, 0.5, 1, 0.5,
0.5, 0.5, 0.5, 0.5, 0.5, 1, 0.5]
play_pattern_timed notes, durations
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sonic_play\n melody = melody()\n if melody.respond_to?(:key)\n melody.values().each do |m|\n play_melody(m)\n end\n elsif melody.respond_to?(:length)\n play_melody(melody)\n end\nend",
"def melody scales\n oct = rand(4) + 2\n scales.scale.map {|note|\n MidiCalc.new(Pitch.new(note, oct)... | [
"0.5689487",
"0.5610979",
"0.5496072",
"0.53168225",
"0.53168225",
"0.53135484",
"0.525182",
"0.523211",
"0.52100754",
"0.51611793",
"0.51607376",
"0.5160605",
"0.5135828",
"0.51087326",
"0.5060653",
"0.50372255",
"0.50335836",
"0.5019475",
"0.5014859",
"0.5014116",
"0.500622... | 0.49607924 | 33 |
=== GET /users/sign_in Prompt the user for login credentials. | def new
__log_activity
__debug_route
opt = request_parameters
mode = opt.delete(:mode)&.to_sym
if mode == :local
redirect_to **opt.merge(action: :sign_in_local)
else
super
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sign_in(user)\n post sessions_path, params: { email: user.email, password: 'mypass' }\n end",
"def sign_in(user:, password:)\n post user_session_path \\\n \"user[email]\" => user.email,\n \"user[password]\" => password\n end",
"def sign_in\n user = User.where(email: params[:email]).... | [
"0.72909904",
"0.7264092",
"0.72614306",
"0.71818787",
"0.71812695",
"0.7152444",
"0.712056",
"0.7087793",
"0.7067224",
"0.70407426",
"0.7010011",
"0.6999425",
"0.6976138",
"0.6962721",
"0.6926929",
"0.69196165",
"0.69195765",
"0.69116277",
"0.68751633",
"0.68626416",
"0.6826... | 0.0 | -1 |
=== POST /users/sign_in Begin login session. | def create
__debug_route
__debug_request
self.resource = warden.authenticate!(auth_options)
__log_activity("LOGIN #{resource}")
remember_dev(resource)
set_flash_notice
sign_in_and_redirect(resource)
rescue => error
auth_failure_redirect(message: error)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sign_in(user, password)\n post login_path, params: {session: {email: user.email, password: password}}\n end",
"def sign_in(user)\n post sessions_path, params: { email: user.email, password: 'mypass' }\n end",
"def sign_in\n request.session = { authorized: true }\n end",
"def sign_in(user:, pa... | [
"0.79274213",
"0.78600895",
"0.763764",
"0.75835574",
"0.75568265",
"0.74268603",
"0.7421098",
"0.74129903",
"0.73515636",
"0.72604233",
"0.7215557",
"0.7187516",
"0.7175545",
"0.71361595",
"0.713236",
"0.713236",
"0.713236",
"0.713236",
"0.7127812",
"0.7116439",
"0.7054774",... | 0.0 | -1 |
=== DELETE /users/sign_out[?revoke=(true|false)] End login session. If the "no_revoke" parameter is missing or "false" then the local session if BS_AUTH is ended _and_ its associated OAuth2 token is revoked. If "no_revoke" is "true" then only the local session is ended. | def destroy
__log_activity("LOGOUT #{current_user}")
__debug_route
__debug_request
user = current_user&.account&.dup
opt = BS_AUTH ? { no_revoke: true?(params[:no_revoke]) } : {}
delete_auth_data(**opt)
super
api_clear(user: user)
set_flash_notice(user: user, clear: true)
rescue => error
auth_failure_redirect(message: error)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sign_out\n @logout = true\n authenticate_api_user\n @logout = false\n revoke_access if @current_user\n head :no_content\n end",
"def logout\n RefreshTokenOperation::RevokeRefreshToken.execute(current_user.id)\n\n # rubocop:disable Lint/UselessAssignment\n current_user = nil\n # ru... | [
"0.7238157",
"0.7094469",
"0.7006225",
"0.6948742",
"0.68873465",
"0.6828326",
"0.67722076",
"0.6764159",
"0.6737947",
"0.67361444",
"0.6691414",
"0.6674359",
"0.6651446",
"0.66227126",
"0.661193",
"0.65775186",
"0.65605307",
"0.65486467",
"0.65355927",
"0.652321",
"0.6521243... | 0.6580087 | 15 |
=== GET /users/sign_in_local Sign in with an EMMA user account encrypted password. | def sign_in_local
__log_activity
__debug_route
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sign_in\n user = User.where(email: params[:email]).first\n return render_invalid_auth unless user && user.valid_password?(params[:password])\n @current_user = user\n render json: slice_token(valid_token), status: :ok\n end",
"def authentication_local_params\n params.require(:authentication_... | [
"0.63777214",
"0.62652266",
"0.61141634",
"0.6089693",
"0.60635245",
"0.59999186",
"0.59986657",
"0.59849536",
"0.5982441",
"0.59782016",
"0.59101385",
"0.59056103",
"0.59056103",
"0.58835596",
"0.5883545",
"0.5882973",
"0.58626485",
"0.58592206",
"0.583684",
"0.5811934",
"0.... | 0.57075334 | 37 |
=== GET /users/sign_in_as?uid=NAME&token=AUTH_TOKEN === GET /users/sign_in_as?auth=(OmniAuth::AuthHash) Sign in using information supplied outside of the OAuth2 flow. | def sign_in_as
__debug_route
__debug_request
local_sign_in
__log_activity("LOGIN #{resource}")
set_flash_notice(action: :create)
auth_success_redirect
rescue => error
auth_failure_redirect(message: error)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def api_sign_in\n user = users(:one)\n post '/auth/sign_in', params: { email: user.uid, password: \"secret123\" }\n\n return { \n \"uid\" => response.headers[\"uid\"],\n \"access-token\" => response.headers[\"access-token\"],\n \"client\" => response.headers[\"client\"] }\n end",
"def si... | [
"0.6602352",
"0.6598152",
"0.6483034",
"0.6409714",
"0.6385592",
"0.636376",
"0.63550264",
"0.6329455",
"0.6293483",
"0.62052214",
"0.61323065",
"0.6119411",
"0.60984284",
"0.60722965",
"0.6063199",
"0.6053339",
"0.60436136",
"0.6036415",
"0.60356295",
"0.6032847",
"0.6005331... | 0.6240235 | 9 |
Called to avoid timingout waiting for credentials. | def no_devise_timeout
request.env['devise.skip_timeout'] = true
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def credentials; end",
"def credentials; end",
"def credentials; end",
"def credentials; end",
"def credentials; end",
"def credentials\n @lock.synchronize do\n @credentials\n end\n end",
"def check_new_credentials(state, context)\n put(:sync, @lock_data)\n ... | [
"0.64727473",
"0.64727473",
"0.64727473",
"0.64727473",
"0.64727473",
"0.6297684",
"0.62911344",
"0.6118305",
"0.60891014",
"0.60891014",
"0.60341734",
"0.60341734",
"0.5935881",
"0.59266216",
"0.59127474",
"0.5888399",
"0.58535355",
"0.5849027",
"0.5801665",
"0.5747542",
"0.... | 0.0 | -1 |
=== Delete user folder. Delete an user folder. ==== Parameters id:: (Integer) User folder id. ==== Example | def delete_user_folder(id)
@client.raw('delete', "/helpers/folders/#{id}")
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_folder(folder_id)\n perform_post_with_unparsed_response('/api/1.1/folders/delete', folder_id: folder_id)\n true\n end",
"def delete_folder folder_id\n delete(\"/projects/#{folder_id}\", code: 204)\n end",
"def delete(conn_id, path, *args)\n options = args.extr... | [
"0.7411968",
"0.73367524",
"0.6637779",
"0.6517919",
"0.6500957",
"0.6489535",
"0.6480606",
"0.6428332",
"0.6427941",
"0.63929373",
"0.63716435",
"0.6371543",
"0.6360025",
"0.6360025",
"0.6345639",
"0.634207",
"0.63361686",
"0.62695694",
"0.6268153",
"0.6222434",
"0.6220549",... | 0.8935011 | 0 |
method: select of main items from navbar by swipe | def select_menu_item(value)
#checking for reach end of list( get_source is current screen id)
current_screen = get_source
previous_screen = ""
until (exists {find_element(id:"design_navigation_view").find_element(xpath:"//android.widget.CheckedTextView[@text='#{value}']")}) || (current_screen == previous_screen) do
Appium::TouchAction.new.swipe(start_x:0.5,start_y: 0.8,end_x:0.5,end_y:0.2,duration:500).perform
previous_screen = current_screen
current_screen = get_source
end
#add more information in case of errors
if exists {find_element(id:"design_navigation_view").find_element(xpath:"//android.widget.CheckedTextView[@text='#{value}']")}
find_element(id:"design_navigation_view").find_element(xpath:"//android.widget.CheckedTextView[@text='#{value}']").click
else
fail("Element #{value} was not found in menu")
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main_menu_nav(main_menu_item)\n main_menu_items.each do |item|\n if item.text == main_menu_item\n item.click\n break\n end\n end\n end",
"def select_item\n @selected = @current\n\n items\n end",
"def scroll_unselected\n return_scene\n... | [
"0.6125035",
"0.6038753",
"0.59857714",
"0.57989955",
"0.5779028",
"0.5702883",
"0.55541325",
"0.5528191",
"0.5503844",
"0.5492701",
"0.54924935",
"0.54562044",
"0.53895134",
"0.5377706",
"0.5371623",
"0.5352227",
"0.53499633",
"0.53451324",
"0.53328437",
"0.5324717",
"0.5311... | 0.58910626 | 3 |
Identifiant path de l'article C'est le chemin relatif dans ./public/page/article, sans l'extension Par exemple : 'theme/contre/lire_en_jouant' | def idpath; @idpath ||= define_idpath end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def article_path(article)\r\n article.id + \".html\"\r\n end",
"def folder\n @folder ||= File.join('.', 'public', 'page', 'article')\n end",
"def relative_path\n @rel_path ||= begin \n date_array = id.split(\"-\")[0..2]\n date_path = date_array.join(\"/\")\n article_id... | [
"0.7478039",
"0.68389994",
"0.64164335",
"0.6415891",
"0.641388",
"0.6324397",
"0.63165057",
"0.6256284",
"0.62467015",
"0.62446445",
"0.62171227",
"0.6180002",
"0.6177298",
"0.61214834",
"0.6070719",
"0.607036",
"0.6051955",
"0.60434127",
"0.6033942",
"0.5991667",
"0.5982649... | 0.0 | -1 |
ex input: a = 14 b = 5 c = 0 def find_middle(a, b, c) arr = [a, b, c] sorted_array = arr.sort sorted_array[1] end | def find_middle(a,b,c)
# 1. declare variable middle
# 2. loop through and check if middle is greater than one and less than the other
middle = a
if (b > a && b < c) || (b < a && b > cc)
middle = b
elsif (c > a && c < b) || (c < a && c > b)
middle = c
end
middle
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_middle(high_idx, low_idx)\n return (high_idx + low_idx) / 2\nend",
"def find_middle_array_element(array)\n\n return 0 if array.size == 1 \n if array.size.odd?\n array.size/2\n elsif array.size.even? \n (array.size/2) - 1\n end\n\nend",
"def find_middle_value\r\n middle_index = sel... | [
"0.71131504",
"0.7105942",
"0.6869463",
"0.6817721",
"0.6817251",
"0.6810298",
"0.67987335",
"0.6786141",
"0.67343956",
"0.67343956",
"0.6720159",
"0.6719669",
"0.67164534",
"0.66803724",
"0.66761994",
"0.66695404",
"0.6661487",
"0.6616747",
"0.6566202",
"0.6556854",
"0.65071... | 0.8443515 | 0 |
string outputs: string reqs: return the input string with all chars dbld rules: none datastruct: array (access to 'map' method) algo: split the input str into chars for each char in the array map the char 2 times back into the array join the array chars into a new str output the new str | def repeater(str)
str.chars.map { |char| char * 2 }.join
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compress_str(str)\n compress = str.gsub(/(.)\\1*/).to_a\n hash = Hash.new(0)\n arr = []\n compress.each do |len|\n if len.length < 2\n arr << len\n else\n arr << len.length\n arr << len\n end\n end\n\n new_arr = arr.map {|a| a.to_s}\n\n new_arr.each_with_index do |compact, i|\n ... | [
"0.69384617",
"0.68537015",
"0.67426854",
"0.67331374",
"0.6674006",
"0.66736305",
"0.6561284",
"0.6531847",
"0.65160406",
"0.65157795",
"0.65023214",
"0.64807236",
"0.6457886",
"0.6447938",
"0.643079",
"0.6423801",
"0.6396762",
"0.63862896",
"0.63719046",
"0.63653135",
"0.63... | 0.6030293 | 72 |
def current_player(board) if turn_count(board) % 2 == 0 return "X" else return "O" end end | def current_player(board)
turn_count(board) % 2 == 0 ? "X" : "O"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def current_player(board)\n if turn_count(board) == 0\n return \"X\"\n elsif\n turn_count(board) % 2 == 0 \n return \"X\"\n else\n return \"O\"\n end \n end",
"def current_player(board)\n if turn_count(board) == 0\n return \"X\"\n elsif\n turn_count(board) % 2 == ... | [
"0.9867085",
"0.9867085",
"0.9805003",
"0.97861916",
"0.97775525",
"0.977015",
"0.9765446",
"0.9752696",
"0.9745607",
"0.9745607",
"0.9745607",
"0.9745607",
"0.9745607",
"0.9745607",
"0.9745607",
"0.9744297",
"0.9733366",
"0.9730234",
"0.97253656",
"0.9722825",
"0.9693018",
... | 0.97210616 | 23 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.