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 |
|---|---|---|---|---|---|---|
Sends the response back to the requester instance | def send_response(uuid, message)
while true
unless is_locked? response_file
lock_file response_file
open(response_file, "a") do |file|
file.write("#{uuid}>>\n")
end
open(response_file, "a") do |file|
file.write("#{message}\n")
end
open(response_file, "a") do |file|
file.write("<<#{uuid}\n")
end
unlock_file response_file
return
end
sleep(0.1)
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_response\r\n if self.response.class.name == \"Proc\"\r\n return self.response.call\r\n end\r\n self.response\r\n end",
"def send_request\n @response = _send_request\n end",
"def send_response\n\t\t\tsend_headers\n\t\t\tsend_body\n\t\t\tsend_trailer\n\t\t\tclose_connection_after_... | [
"0.7569459",
"0.72112834",
"0.6902521",
"0.682388",
"0.674784",
"0.67368865",
"0.67181146",
"0.67181146",
"0.67181146",
"0.67181146",
"0.67181146",
"0.67181146",
"0.67181146",
"0.67181146",
"0.67181146",
"0.67181146",
"0.67181146",
"0.67181146",
"0.67181146",
"0.667778",
"0.6... | 0.0 | -1 |
Retrieves a response from the listener via the response file | def retrieve_response(uuid)
response = false
remaining_file_contents = []
message_has_begun = false
message_has_ended = false
if FileTest::file? response_file and not is_locked? response_file
lock_file response_file
open(response_file, "r") do |file|
while (line = file.gets)
if (line == "#{uuid}>>" or line == "#{uuid}>>\n") and not message_has_begun
message_has_begun = true
response = []
next
elsif (line == "<<#{uuid}" or line == "<<#{uuid}\n") and message_has_begun
message_has_ended = true
next
end
if message_has_begun and not message_has_ended
response.push line
else
remaining_file_contents.push line
end
end
end
if response and remaining_file_contents.first
open(response_file, "w") do |file|
file.write(remaining_file_contents.join() + "\n")
end
elsif response
open(response_file, "w") {}
end
unlock_file response_file
end
response
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def response_file\n @notifier_engine.response_file\n end",
"def receive_response(response); end",
"def _receive_response opaque\n _read stream\n end",
"def retrieve_response\n session.post(url)\n end",
"def read_unparsed_response(filename)\n File.read(\"spec/fixtures/... | [
"0.687731",
"0.664301",
"0.6596049",
"0.63064325",
"0.6252205",
"0.62115574",
"0.6162234",
"0.6156959",
"0.6140987",
"0.61402243",
"0.61402243",
"0.61402243",
"0.61402243",
"0.61402243",
"0.61402243",
"0.61402243",
"0.61402243",
"0.61402243",
"0.61402243",
"0.61402243",
"0.61... | 0.6319434 | 3 |
Returns the path to the request file | def request_file
@notifier_engine.request_file
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def request_path\n @request_path ||= ::File.expand_path(::File.join(root_dir, ::Rack::Utils.unescape(path_info)))\n end",
"def path\n request.path\n end",
"def get_request_file root, req_path, method, default=''\n path = File.join root, req_path\n file = \"#{path}.#{method}\"\n\n retur... | [
"0.78012335",
"0.7460241",
"0.7295718",
"0.7248919",
"0.71520346",
"0.7149989",
"0.71346235",
"0.7084104",
"0.7083163",
"0.7082977",
"0.7058109",
"0.70255727",
"0.70001894",
"0.6976696",
"0.6962112",
"0.6958151",
"0.6951989",
"0.6920488",
"0.69173443",
"0.6911228",
"0.6907688... | 0.74451673 | 2 |
Returns the path to the response file | def response_file
@notifier_engine.response_file
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def response_uri(file)\n file.base_uri\n end",
"def get_file_path\n @path\n end",
"def path\n metadata.fetch(:path) do\n return if request_response_pairs.empty?\n request_response_pairs.first.first.path\n end\n end",
"def path\n file.url\n end",
... | [
"0.69164526",
"0.68736947",
"0.6842221",
"0.67960364",
"0.67575",
"0.6753498",
"0.6738247",
"0.6712754",
"0.6701456",
"0.6618752",
"0.6607714",
"0.656819",
"0.6522459",
"0.65216684",
"0.65156937",
"0.65154207",
"0.65076214",
"0.64752626",
"0.64742196",
"0.6417601",
"0.6416827... | 0.77882975 | 0 |
Adds a lock file to mark the given file as locked | def lock_file file
file_lock = file + ".lock"
open(file_lock, "w") {}
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_lock\n FileUtils.touch(@lock_file)\n end",
"def set_lock\n if File.exists? lock_file_name\n false\n else\n FileUtils.touch lock_file_name\n true\n end\n end",
"def lock(name)\n lock_file = $lock_dir + '/' + name\n unless FileTest.exist?(lock_file)\n ... | [
"0.74842393",
"0.723057",
"0.69049996",
"0.6763062",
"0.6742792",
"0.66182196",
"0.6540233",
"0.6536679",
"0.6534776",
"0.6415368",
"0.6392145",
"0.637959",
"0.6365999",
"0.6349172",
"0.6322275",
"0.63093495",
"0.62923115",
"0.6253187",
"0.6200376",
"0.6192895",
"0.6117079",
... | 0.7412491 | 1 |
Deletes a lock file to mark the given file as unlocked | def unlock_file file
file_lock = file + ".lock"
File.delete(file_lock) if FileTest::file? file_lock
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unlock!\n FileUtils.rm_f @path\n end",
"def remove_lock\n File.delete(@lock_file)\n end",
"def delete\n File::unlink @path+\".lock\" rescue nil\n File::unlink @path+\".new\" rescue nil\n File::unlink @path rescue nil\n end",
"def delete\n File::unlink @path+\".loc... | [
"0.80032617",
"0.79791397",
"0.7829483",
"0.78129536",
"0.7449344",
"0.7435107",
"0.7431346",
"0.7348802",
"0.73211664",
"0.7310665",
"0.7248773",
"0.7200551",
"0.7200551",
"0.7197581",
"0.7130013",
"0.7085734",
"0.70229983",
"0.6945256",
"0.6914487",
"0.69054306",
"0.6878646... | 0.80220586 | 0 |
Checks for a lock file to see if the given file is marked as locked | def is_locked? file
file_lock = file + ".lock"
FileTest::file? file_lock
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def locked?\n File.exist?(lock_file)\n end",
"def locked?\n File.exist?(lock_file)\n end",
"def unlocked?\n ! File.exist?(lock_file)\n end",
"def lock_file_present?(lfname)\n begin\n # TODO check lock file age and send a warning if it is older than a\n # given thr... | [
"0.8242603",
"0.8170683",
"0.7804606",
"0.77444834",
"0.7585008",
"0.745492",
"0.7408756",
"0.7318413",
"0.725163",
"0.7199684",
"0.7184479",
"0.6885824",
"0.684168",
"0.6773479",
"0.6763866",
"0.67473966",
"0.6743399",
"0.67100096",
"0.66962045",
"0.6685964",
"0.6681089",
... | 0.84481305 | 0 |
Resets the SMTP connection. | def reset
getok 'RSET'
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset_connection!\n @@socket = nil\n end",
"def reset\n self.class.reset :email => self.email\n end",
"def reset_connection!\n @connection = nil\n end",
"def reset!\n reconnect!\n end",
"def reset\n @config = nil\n @client = nil\n end",
"def reset_... | [
"0.69499886",
"0.69232136",
"0.6734722",
"0.66285425",
"0.6316605",
"0.6103816",
"0.60773754",
"0.60683626",
"0.6038048",
"0.6016561",
"0.6001744",
"0.59982634",
"0.59467226",
"0.593634",
"0.59036905",
"0.5871792",
"0.58409935",
"0.58096534",
"0.57931465",
"0.57733536",
"0.57... | 0.0 | -1 |
Creates a new ARSendmail. Valid options are: :BatchSize:: Maximum number of emails to send per delay :Delay:: Delay between deliver attempts :Once:: Only attempt to deliver emails once when run is called :Verbose:: Be verbose. | def initialize(options = {})
options[:Delay] ||= 60
options[:MaxAge] ||= 86400 * 7
@batch_size = options[:BatchSize]
@delay = options[:Delay]
@once = options[:Once]
@verbose = options[:Verbose]
@max_age = options[:MaxAge]
@failed_auth_count = 0
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_mail(options = {})\n options = {\n :subject => \"Message From RED.com\",\n :cc => \"\",\n :from => AppConfig.ORDERS_FROM,\n }.merge!(options)\n \n # send mail under development and test environment.\n begin\n mail = MailTaskMailer.send \"create_... | [
"0.63072395",
"0.60921854",
"0.5843758",
"0.5818419",
"0.57861686",
"0.5693555",
"0.5662575",
"0.5598568",
"0.55856764",
"0.5576574",
"0.55601513",
"0.5545754",
"0.5479371",
"0.54689413",
"0.5461727",
"0.5461727",
"0.543405",
"0.5405515",
"0.5372719",
"0.53496534",
"0.5343981... | 0.51263106 | 51 |
Removes emails that have lived in the queue for too long. If max_age is set to 0, no emails will be removed. | def cleanup
return if @max_age == 0
timeout = Time.now - @max_age
conditions = ['last_send_attempt > 0 and created_on < ?', timeout]
mail = ActionMailer::Base.email_class.destroy_all conditions
log "expired #{mail.length} emails from the queue"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def purge\n t = Time.now\n expired = []\n @queue.each do |identity,worker|\n expired << identity if t > worker.expiry\n end\n expired.each do |identity|\n @queue.delete identity\n end\n end",
"def check_message_age\n return unless @mode == :max_age\n\n @history_mutex.synchroniz... | [
"0.63043463",
"0.6104571",
"0.60924995",
"0.59141535",
"0.58153975",
"0.5702343",
"0.5679355",
"0.56576204",
"0.56454504",
"0.55729336",
"0.5532184",
"0.5510853",
"0.54192036",
"0.53731483",
"0.53593457",
"0.52464926",
"0.52125144",
"0.5202066",
"0.5199674",
"0.51825273",
"0.... | 0.7539608 | 0 |
Delivers +emails+ to ActionMailer's SMTP server and destroys them. | def deliver(emails)
settings = [
smtp_settings[:domain],
(smtp_settings[:user] || smtp_settings[:user_name]),
smtp_settings[:password],
smtp_settings[:authentication]
]
smtp = Net::SMTP.new(smtp_settings[:address], smtp_settings[:port])
if smtp.respond_to?(:enable_starttls_auto)
smtp.enable_starttls_auto unless smtp_settings[:tls] == false
else
settings << smtp_settings[:tls]
end
smtp.start(*settings) do |session|
@failed_auth_count = 0
until emails.empty? do
email = emails.shift
begin
res = session.send_message email.mail, email.from, email.to
email.destroy
log "sent email %011d from %s to %s: %p" %
[email.id, email.from, email.to, res]
rescue Net::SMTPFatalError => e
log "5xx error sending email %d, removing from queue: %p(%s):\n\t%s" %
[email.id, e.message, e.class, e.backtrace.join("\n\t")]
email.destroy
session.reset
rescue Net::SMTPServerBusy => e
log "server too busy, stopping delivery cycle"
return
rescue Net::SMTPUnknownError, Net::SMTPSyntaxError, TimeoutError, Timeout::Error => e
email.last_send_attempt = Time.now.to_i
email.save rescue nil
log "error sending email %d: %p(%s):\n\t%s" %
[email.id, e.message, e.class, e.backtrace.join("\n\t")]
session.reset
end
end
end
rescue Net::SMTPAuthenticationError => e
@failed_auth_count += 1
if @failed_auth_count >= MAX_AUTH_FAILURES then
log "authentication error, giving up: #{e.message}"
raise e
else
log "authentication error, retrying: #{e.message}"
end
sleep delay
rescue Net::SMTPServerBusy, SystemCallError, OpenSSL::SSL::SSLError
# ignore SMTPServerBusy/EPIPE/ECONNRESET from Net::SMTP.start's ensure
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear_emails\n ActionMailer::Base.deliveries = []\n end",
"def send_emails\n mail = build_mail\n get_recipients do |recipient|\n unless EmailResponse.exists?(email: recipient.email) # bounces & complaints\n mail.to = recipient.email\n replace_and_send_mail_safely(ma... | [
"0.74359477",
"0.68675333",
"0.6793968",
"0.62474155",
"0.6243085",
"0.6225857",
"0.62187994",
"0.5949341",
"0.589956",
"0.58162725",
"0.58092415",
"0.58041835",
"0.57886827",
"0.5768428",
"0.5722108",
"0.57078016",
"0.57051814",
"0.5694457",
"0.5667452",
"0.5666899",
"0.5567... | 0.66649336 | 3 |
Prepares ar_sendmail for exiting | def do_exit
log "caught signal, shutting down"
self.class.remove_pid_file
exit 130
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def finish\n self.class.debug_log(\"SAVE #{flavor} \" \\\n \"from=#{begin\n user.login\n rescue StandardError\n \"nil\"\n end} \" \\\n \"to=#{begin\n to_user.login\n rescue StandardError\n ... | [
"0.64096594",
"0.63046896",
"0.6223968",
"0.62049866",
"0.6156373",
"0.6145265",
"0.61095536",
"0.60964656",
"0.60909075",
"0.6068805",
"0.60578275",
"0.6021855",
"0.6006213",
"0.5970235",
"0.5966186",
"0.5963216",
"0.593195",
"0.59213984",
"0.59100145",
"0.59066373",
"0.5896... | 0.0 | -1 |
Returns emails in email_class that haven't had a delivery attempt in the last 300 seconds. | def find_emails
options = { :conditions => ['last_send_attempt < ?', Time.now.to_i - 300] }
options[:limit] = batch_size unless batch_size.nil?
mail = ActionMailer::Base.email_class.find :all, options
log "found #{mail.length} emails to send"
mail
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cleanup\n return if @max_age == 0\n timeout = Time.now - @max_age\n conditions = ['last_send_attempt > 0 and created_on < ?', timeout]\n mail = ActionMailer::Base.email_class.destroy_all conditions\n\n log \"expired #{mail.length} emails from the queue\"\n end",
"def failed_email_delivery_con... | [
"0.6338834",
"0.62829703",
"0.6016158",
"0.59370136",
"0.59082866",
"0.59031725",
"0.5732845",
"0.5668763",
"0.56676126",
"0.56510174",
"0.5649144",
"0.5623214",
"0.56188136",
"0.5539433",
"0.5513033",
"0.548464",
"0.547614",
"0.5413971",
"0.5383844",
"0.5371349",
"0.5368477"... | 0.6174087 | 2 |
Installs signal handlers to gracefully exit. | def install_signal_handlers
trap 'TERM' do do_exit end
trap 'INT' do do_exit end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_signal_handlers\n trap('TERM') { shutdown }\n trap('INT') { shutdown }\n trap('QUIT') { shutdown }\n trap 'SIGHUP', 'IGNORE'\n end",
"def register_signal_handlers!\n trap('TERM') { shutdown }\n trap('INT') { shutdown }\n end",
"def register_signal_handlers\r... | [
"0.8189762",
"0.8168444",
"0.8119747",
"0.80708",
"0.7970652",
"0.78447163",
"0.7837409",
"0.7819602",
"0.77881527",
"0.7617676",
"0.7567327",
"0.7396383",
"0.7375882",
"0.7375882",
"0.73699605",
"0.723577",
"0.7232138",
"0.7231227",
"0.7207219",
"0.71948266",
"0.71801347",
... | 0.83130765 | 0 |
Logs +message+ if verbose | def log(message)
$stderr.puts message if @verbose
ActionMailer::Base.logger.info "ar_sendmail: #{message}"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log(message)\n return unless @verbose\n $stderr.puts \"# #{message}\"\n end",
"def log!(message)\n log message if very_verbose\n end",
"def log!(message)\n log message if very_verbose\n end",
"def log(message)\n if verbose\n puts \"*** #{message}\"\n elsif very_ver... | [
"0.8352958",
"0.8157226",
"0.8157226",
"0.81308246",
"0.80214804",
"0.80214804",
"0.7967452",
"0.7953367",
"0.7953367",
"0.79129297",
"0.7716047",
"0.7712895",
"0.74951714",
"0.7466741",
"0.7466741",
"0.7459356",
"0.7459356",
"0.73118764",
"0.73118764",
"0.73118764",
"0.72823... | 0.66669965 | 42 |
Scans for emails and delivers them every delay seconds. Only returns if once is true. | def run
install_signal_handlers
loop do
begin
cleanup
emails = find_emails
deliver(emails) unless emails.empty?
rescue ActiveRecord::Transactions::TransactionError
end
break if @once
sleep @delay
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mail_flush\n @mails_mutex.synchronize do\n self.log_puts(\"Flushing mails.\") if @debug\n \n if @mails_waiting.empty?\n self.log_puts(\"No mails to flush - skipping.\") if @debug\n return false\n end\n \n self.log_puts(\"Trying to ping Google to figure out if we a... | [
"0.63550395",
"0.6347368",
"0.626558",
"0.59199774",
"0.5908429",
"0.587785",
"0.5820501",
"0.5771507",
"0.57566583",
"0.57563657",
"0.57034516",
"0.5688156",
"0.56687874",
"0.5662345",
"0.5656551",
"0.56368244",
"0.56352085",
"0.56224275",
"0.5572542",
"0.5552031",
"0.554981... | 0.6537431 | 0 |
Proxy to ActionMailer::Base::smtp_settings. See for instructions on how to configure ActionMailer's SMTP server. Falls back to ::server_settings if ::smtp_settings doesn't exist for backwards compatibility. | def smtp_settings
ActionMailer::Base.smtp_settings rescue ActionMailer::Base.server_settings
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def smtp_settings\n {\n address: smtp_host,\n password: smtp_password,\n port: smtp_port,\n user_name: smtp_username\n }\n end",
"def ar_mailer_smtp_settings(new_settings = nil)\n ar_mailer_setting(:smtp_settings, new_settings)\n end",
"def config_mail\n ActionMailer::Base.rai... | [
"0.7337555",
"0.70797634",
"0.6887633",
"0.68011665",
"0.647581",
"0.61760986",
"0.61746866",
"0.6158605",
"0.61229014",
"0.61000836",
"0.5971139",
"0.5930409",
"0.5810709",
"0.5719685",
"0.5672785",
"0.56592274",
"0.5651816",
"0.5587288",
"0.55766714",
"0.55448157",
"0.55086... | 0.7799035 | 0 |
Returns the configured user name or the user name of the authenticated user | def get_username
@user_name ||= self.user.username
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hubssolib_get_user_name\n user = self.hubssolib_current_user\n user ? user.user_real_name : nil\n end",
"def current_user_name\n logged_in? ? (user_name(current_user_id) || current_user_id) : nil\n end",
"def user_name\n user ? user.name : ''\n end",
"def user_name\n user ? user.n... | [
"0.78359973",
"0.78038925",
"0.7777572",
"0.7777572",
"0.7777572",
"0.7777572",
"0.7777572",
"0.7777572",
"0.7777572",
"0.7777572",
"0.7777572",
"0.7777572",
"0.7578591",
"0.75677633",
"0.7562504",
"0.75109655",
"0.75097305",
"0.7488156",
"0.7485541",
"0.74659586",
"0.7445601... | 0.78224754 | 1 |
GET /post117s/1 GET /post117s/1.xml | def show
@post117 = Post117.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @post117 }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show\n @post57 = Post57.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @post57 }\n end\n end",
"def show\n @post181 = Post181.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml ... | [
"0.65125257",
"0.6474304",
"0.6473282",
"0.64366126",
"0.6436177",
"0.64304566",
"0.6429331",
"0.64280576",
"0.6418291",
"0.6407826",
"0.64053935",
"0.6395737",
"0.6394166",
"0.6383656",
"0.6381754",
"0.63811916",
"0.6380231",
"0.6357893",
"0.6352695",
"0.634823",
"0.6344668"... | 0.64644295 | 3 |
GET /post117s/new GET /post117s/new.xml | def new
@post117 = Post117.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @post117 }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n @post101 = Post101.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @post101 }\n end\n end",
"def new\n @post57 = Post57.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @post57 }\n ... | [
"0.75954574",
"0.758967",
"0.757236",
"0.756434",
"0.7548778",
"0.752965",
"0.7520364",
"0.7510966",
"0.7508617",
"0.7507032",
"0.7503816",
"0.74995655",
"0.7499221",
"0.74964774",
"0.7485347",
"0.7484131",
"0.74817634",
"0.74765676",
"0.7469042",
"0.74688035",
"0.74599946",
... | 0.7571219 | 3 |
POST /post117s POST /post117s.xml | def create
@post117 = Post117.new(params[:post117])
respond_to do |format|
if @post117.save
format.html { redirect_to(@post117, :notice => 'Post117 was successfully created.') }
format.xml { render :xml => @post117, :status => :created, :location => @post117 }
else
format.html { render :action => "new" }
format.xml { render :xml => @post117.errors, :status => :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(xmldoc)\n headers = {'Content-Type' => 'text/xml'}\n check_response( @httpcli.post(@endpoint, xmldoc, headers) )\n end",
"def create\n @post168 = Post168.new(params[:post168])\n\n respond_to do |format|\n if @post168.save\n format.html { redirect_to(@post168, :notice => 'Post168... | [
"0.6150349",
"0.6100429",
"0.60998875",
"0.6057699",
"0.6021955",
"0.5993395",
"0.59479654",
"0.5913706",
"0.5904326",
"0.5886781",
"0.5860558",
"0.5848142",
"0.5830541",
"0.58173597",
"0.5811431",
"0.5805381",
"0.58032405",
"0.5795835",
"0.5795161",
"0.57806975",
"0.5775407"... | 0.61656487 | 0 |
PUT /post117s/1 PUT /post117s/1.xml | def update
@post117 = Post117.find(params[:id])
respond_to do |format|
if @post117.update_attributes(params[:post117])
format.html { redirect_to(@post117, :notice => 'Post117 was successfully updated.') }
format.xml { head :ok }
else
format.html { render :action => "edit" }
format.xml { render :xml => @post117.errors, :status => :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put(uri, xml)\r\n req = Net::HTTP::Put.new(uri)\r\n req[\"content-type\"] = \"application/xml\"\r\n req.body = xml\r\n request(req)\r\n end",
"def update opts = {}\n opts[:headers] ||= {}\n opts[:headers]['Content-Type'] ||= 'text/xml'\n post 'update', opts\n end",
"def res... | [
"0.67678404",
"0.66173536",
"0.6266552",
"0.61783946",
"0.61027867",
"0.59287935",
"0.59222645",
"0.58906674",
"0.58421564",
"0.58337575",
"0.5825395",
"0.5824342",
"0.5819265",
"0.5790514",
"0.5786169",
"0.5784403",
"0.57778794",
"0.5777686",
"0.5771373",
"0.5770281",
"0.576... | 0.5727579 | 25 |
DELETE /post117s/1 DELETE /post117s/1.xml | def destroy
@post117 = Post117.find(params[:id])
@post117.destroy
respond_to do |format|
format.html { redirect_to(post117s_url) }
format.xml { head :ok }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @post157 = Post157.find(params[:id])\n @post157.destroy\n\n respond_to do |format|\n format.html { redirect_to(post157s_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n RestClient.delete \"#{REST_API_URI}/contents/#{id}.xml\" \n self\n end",
"def destro... | [
"0.6898121",
"0.68844515",
"0.6882725",
"0.6882469",
"0.6879654",
"0.6848951",
"0.6847906",
"0.68160486",
"0.6813747",
"0.6812191",
"0.6785004",
"0.67823327",
"0.6778331",
"0.67765474",
"0.6767269",
"0.6765122",
"0.67571676",
"0.6751022",
"0.67475027",
"0.6740799",
"0.6738336... | 0.6716402 | 23 |
Check if run exists | def authenticate_run
@run = Run.find_by(id: params[:id])
redirect_unauthorized if @run.nil?
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_run?(filename)\n if @db.schema_schema_evolution_manager_exists?\n query = \"select count(*) from %s.%s where filename = '%s'\" % [Db.schema_name, @table_name, filename]\n @db.psql_command(query).to_i > 0\n else\n false\n end\n end",
"def program_name?\n \"runs\"\... | [
"0.69411874",
"0.6762034",
"0.6761944",
"0.6740095",
"0.66968775",
"0.6564842",
"0.6489842",
"0.6417676",
"0.6411314",
"0.6394912",
"0.6367646",
"0.63660246",
"0.63403803",
"0.6293206",
"0.6248377",
"0.62458926",
"0.622151",
"0.6219524",
"0.6213947",
"0.62089306",
"0.62089306... | 0.0 | -1 |
Check if run belongs to current user | def authenticate_correct_user
redirect_unauthorized unless current_user? @run.user_id
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_as_user\n @run_as_user\n end",
"def mine?\n user && user.username == Codeplane.username\n end",
"def current?(user)\n Process.uid == Etc.getpwnam(user).uid\n rescue\n false\n end",
"def check_if_current_user\r\n User.current_user && User.current_user != ... | [
"0.71932",
"0.7009558",
"0.69457126",
"0.68529034",
"0.68505514",
"0.68221825",
"0.6819712",
"0.6819712",
"0.67402774",
"0.67269695",
"0.6722941",
"0.6721632",
"0.67028195",
"0.6685449",
"0.6668778",
"0.6666271",
"0.6664473",
"0.6634006",
"0.6623682",
"0.66184974",
"0.6595877... | 0.63702464 | 71 |
Allowed parameter for Run model | def run_params
params.require(:run).permit(:distance, :duration, :date)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_params\n params.require(:run).permit(policy(@run || Run).permitted_attributes)\n end",
"def run_params\n params.fetch(:run, {}).permit(:task_name, :batch_size, :embedding_dim, :memory_dim,\n :num_layers, :epochs, :rnn_cell, :ckpt_every,\n ... | [
"0.6817239",
"0.658044",
"0.6508074",
"0.6440833",
"0.64139843",
"0.6397583",
"0.6367931",
"0.63197553",
"0.6316254",
"0.6301247",
"0.6276387",
"0.6247725",
"0.6224823",
"0.62244034",
"0.6222868",
"0.6217057",
"0.6184234",
"0.61792433",
"0.61715466",
"0.617067",
"0.61613023",... | 0.5864251 | 72 |
positive relationship is one when user is explicitly or implicitly following another | def positive?
self.friendship_status >= 0
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def relationship(user)\n Following.where(:follower_id => self, :followed_id => user).first.try(:relationship)||\"none\"\n end",
"def confirm_relationship(user, label)\n return false if user.nil? or user == self\n\n edge = self.edges.select { |edge| edge.origin == user and edge.label == label }.firs... | [
"0.71842724",
"0.70794946",
"0.70019114",
"0.69564104",
"0.693185",
"0.6885819",
"0.68707997",
"0.68446976",
"0.68265206",
"0.68265206",
"0.68265206",
"0.68265206",
"0.68265206",
"0.6812651",
"0.67889065",
"0.6758096",
"0.6748795",
"0.67473006",
"0.67473006",
"0.673487",
"0.6... | 0.0 | -1 |
negative relationship is when user is explicitly or implicitly ignoring another user | def negative?
self.friendship_status < 0
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def antiuser(user)\n users.where(['users.id <> ?', user.id]).first\n end",
"def foreign_visitor?\n not user\n end",
"def opposite_member(user)\n user == sender ? receiver : sender\n end",
"def unfollowed(other_user)\n passive_relationships.find_by(follower_id: other_user.id).try(:destroy) \n ... | [
"0.64728737",
"0.64692277",
"0.64584726",
"0.6456072",
"0.64487743",
"0.6421819",
"0.632577",
"0.62560505",
"0.6244611",
"0.6240858",
"0.62392986",
"0.6236118",
"0.62319285",
"0.6223601",
"0.6198454",
"0.6189721",
"0.6183044",
"0.6176503",
"0.61742806",
"0.6155702",
"0.614364... | 0.58788997 | 57 |
subscribed is when user explicitly expressed his will to follow this user | def subscribed?
self.friendship_status > 0
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def subscribed?(user)\n user.subscription.subscribed==true\n end",
"def mark_subscribed!\n return unless with_states?\n\n unless user.subscribed?\n user.skip_mailchimp_callbacks = true\n user.subscribe!\n end\n end",
"def follow(user)\n user.followers << self\n end",
"def follow(u... | [
"0.71816015",
"0.6967649",
"0.6736481",
"0.6670906",
"0.6601106",
"0.6584293",
"0.65720105",
"0.654041",
"0.6488488",
"0.6487327",
"0.6487327",
"0.6487327",
"0.6487327",
"0.6487327",
"0.6487327",
"0.6474473",
"0.6469568",
"0.6453783",
"0.64322865",
"0.6429612",
"0.6425425",
... | 0.67814076 | 2 |
when user explicitly put this relationship in ignored list | def ignored?
self.friendship_status == IGNORED
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ignore_user(user)\n @ignored_ids << user.resolve_id\n end",
"def ignore_user(user)\n @ignored_ids << user.resolve_id\n end",
"def update_ignores\n @ignore_users |= WhitelistedUser.all.map(&:user_id)\n end",
"def ignore(other) \n\trelationship = get_relationship(other)\n\t\n\tif... | [
"0.6539075",
"0.6539075",
"0.6468529",
"0.64467853",
"0.64066225",
"0.6405407",
"0.634686",
"0.63161165",
"0.626644",
"0.6264379",
"0.6182636",
"0.6177682",
"0.61704135",
"0.6018412",
"0.6016715",
"0.601451",
"0.601451",
"0.599538",
"0.59466827",
"0.5938011",
"0.59263134",
... | 0.59087896 | 21 |
when user explicitly put this relationship into blacklist | def blacklisted?
self.friendship_status == BLACKLISTED
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def belongs_blocked\n end",
"def set_blacklist\n @blacklist = Blacklist.find(params[:id])\n end",
"def can_be_blacklisted_by?(user)\n user && user.id != self.user.id # && !user.all_friend_ids.include?(self.user.id)\n end",
"def is_blacklisted_for?(user)\n user && user.id != self.id && self.is_pre... | [
"0.67440283",
"0.6603951",
"0.6373716",
"0.6198405",
"0.61903125",
"0.61262345",
"0.6088608",
"0.6078223",
"0.5835538",
"0.5824821",
"0.5782603",
"0.5773863",
"0.5770175",
"0.5687902",
"0.5681004",
"0.5675676",
"0.56295085",
"0.56037533",
"0.55676603",
"0.55391455",
"0.550090... | 0.5876891 | 8 |
before_filter :is_modifiable?, :only => [:edit,:destroy] | def index
@categories = StudentAttachmentCategory.fetch_all # default.to_a + StudentAttachmentCategory.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prevent_edit\n !can_edit?\n end",
"def can_edit?(user)\n\n end",
"def can_edit\n return current_user && (current_user.id == Integer(params[:id]) || current_user.is_admin)\n end",
"def self_edit_only\n #if current_user.id != Integer(params[:id]) && !current_user.is_admin\n if !can_edit\n... | [
"0.7316895",
"0.7308762",
"0.72315544",
"0.7215147",
"0.71679765",
"0.71378905",
"0.71192855",
"0.71031773",
"0.70906085",
"0.7087532",
"0.7084396",
"0.70609564",
"0.7043817",
"0.7038937",
"0.7000049",
"0.6969783",
"0.69611627",
"0.6961029",
"0.69584954",
"0.6953986",
"0.6952... | 0.0 | -1 |
finally, we print the total | def print_footer(names)
puts "Overall, we have #{names.count} great students"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def total; end",
"def overall_total\n puts \"Portfolio Total: $#{sprintf('%.2f', @all_totals)}\"\n end",
"def total_text\n 'Total: %d' % total\n end",
"def compute_total_and_print()\n @total_price=0\n $final_price_list.each do |element| \n @total_price = @total_price + element\n end\n ... | [
"0.7597549",
"0.7391472",
"0.72371536",
"0.7207085",
"0.7199618",
"0.7165569",
"0.71423566",
"0.7120588",
"0.7080723",
"0.7003194",
"0.69690657",
"0.6957471",
"0.69386023",
"0.6894006",
"0.687692",
"0.6857914",
"0.6855805",
"0.6831855",
"0.6802355",
"0.68019265",
"0.68005437"... | 0.0 | -1 |
Was this notification signalled? | def signalled?
@signalled
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def signalled event\n @signalled_actions and @signalled_actions[event]\n end",
"def notification?\n false\n end",
"def notify?\n true\n end",
"def notify?\n false\n end",
"def notify?\n @notify == true\n end",
"def stalled?\n @stalled_fibers.any?\n end"... | [
"0.7490718",
"0.69758767",
"0.6685281",
"0.6678424",
"0.66641176",
"0.655563",
"0.65138483",
"0.6501493",
"0.64942354",
"0.6467567",
"0.6364986",
"0.63618726",
"0.63499457",
"0.6311807",
"0.6297406",
"0.6202629",
"0.6202183",
"0.61276287",
"0.6102364",
"0.6080565",
"0.6070049... | 0.81212234 | 0 |
Wait/block until a signal is received. Optional timeout. | def wait(timeout: nil)
if timeout
read_ready, _, _ = IO.select([@output], [], [], timeout)
return false unless read_ready and read_ready.any?
end
@signalled or @output.read(1)
# Just in case that this was split across multiple processes.
@signalled = true
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wait(timeout = nil)\n event.wait(timeout) if timeout != 0 && incomplete?\n self\n end",
"def wait_for(timeout = 30, &block)\n start = Time.now\n while true\n raise RuntimeError, \"Timed out waiting for event\" if Time.now - start > timeout\n\n break if yield\n\n sleep(0.1)\n... | [
"0.66175556",
"0.6465666",
"0.6455363",
"0.6455363",
"0.6407712",
"0.6403575",
"0.6252158",
"0.6243102",
"0.6235537",
"0.6137739",
"0.6119742",
"0.6115041",
"0.6089816",
"0.6045781",
"0.6044169",
"0.6001502",
"0.599036",
"0.5983651",
"0.59690267",
"0.59226054",
"0.58967453",
... | 0.5939266 | 19 |
TODO: why does the `alias_method :set, :select` code not work? | def set option_value
self.select option_value
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select\n self[:select]\n end",
"def collection_select(method, collection, value_method, text_method, options = T.unsafe(nil), html_options = T.unsafe(nil)); end",
"def select\n self[:select]\n end",
"def select; end",
"def select; end",
"def select(*) end",
"def method_missi... | [
"0.64982843",
"0.6436249",
"0.6379387",
"0.6364503",
"0.6364503",
"0.6333489",
"0.6188736",
"0.61570793",
"0.61371624",
"0.61162674",
"0.60655445",
"0.6025328",
"0.59941393",
"0.5989292",
"0.59581923",
"0.5867259",
"0.5850999",
"0.5823902",
"0.58019507",
"0.5769136",
"0.57411... | 0.0 | -1 |
Construct a bitset of size one word (64 bits) | def initialize
initialize__bit_set(BITS)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize (size)\n @@wordBits = 0.size * 8 # size of a word on your machine\n @wordMax = 2**@@wordBits\n @xorMask = @wordMax - 1\n @bitMask = [] # to speed things up precompute index masks\n @@wordBits.times { |i| @bitMask[i] = 1 << i }\n @size = size\t ... | [
"0.6654422",
"0.6506331",
"0.62598187",
"0.60825163",
"0.60142285",
"0.590922",
"0.5624886",
"0.558228",
"0.5550751",
"0.5538593",
"0.54852223",
"0.54376096",
"0.5433707",
"0.54301697",
"0.5403291",
"0.5403291",
"0.535716",
"0.53516245",
"0.5316764",
"0.5273681",
"0.52610487"... | 0.5746063 | 6 |
Construction from a static array of longs | def initialize(bits_)
@bits = nil
@bits = bits_
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(seed)\n @index = 0\n @mt = []\n @mt[0] = seed\n (1...ARRAY_LENGTH).each do |i|\n @mt[i] = (2 **32 -1) & (INIT_CONST * (@mt[i-1] ^ (@mt[i-1] >> 30)) + i)\n end\n end",
"def initialize(nbits)\n @bits = nil\n @bits = Array.typed(::Java::Long).new(((nbits - 1) >> LOG_BIT... | [
"0.60069525",
"0.58877397",
"0.5878224",
"0.57672554",
"0.5511404",
"0.54274803",
"0.53788567",
"0.531438",
"0.527068",
"0.5234365",
"0.52026165",
"0.518435",
"0.5168359",
"0.5159016",
"0.5156755",
"0.51354325",
"0.5133837",
"0.5097448",
"0.5056036",
"0.50392073",
"0.50159526... | 0.0 | -1 |
Construct a bitset given the size | def initialize(nbits)
@bits = nil
@bits = Array.typed(::Java::Long).new(((nbits - 1) >> LOG_BITS) + 1) { 0 }
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize (size)\n @@wordBits = 0.size * 8 # size of a word on your machine\n @wordMax = 2**@@wordBits\n @xorMask = @wordMax - 1\n @bitMask = [] # to speed things up precompute index masks\n @@wordBits.times { |i| @bitMask[i] = 1 << i }\n @size = size\t ... | [
"0.6335131",
"0.6134692",
"0.5704021",
"0.55820537",
"0.55785406",
"0.55625993",
"0.5372414",
"0.53715146",
"0.52831906",
"0.52731884",
"0.52588296",
"0.5220683",
"0.51527274",
"0.5128951",
"0.50852776",
"0.5065795",
"0.5051743",
"0.5014575",
"0.49756056",
"0.496662",
"0.4965... | 0.0 | -1 |
or this element into this set (grow as necessary to accommodate) | def add(el)
# System.out.println("add("+el+")");
n = word_number(el)
# System.out.println("word number is "+n);
# System.out.println("bits.length "+bits.length);
if (n >= @bits.attr_length)
grow_to_include(el)
end
@bits[n] |= bit_mask(el)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put(elm)\n resize\n\n i = self.length\n i = @bitmap.next_cell + 1 while i == self.length\n\n begin\n self[i] = elm\n @bitmap.mark_cell(i - 1)\n rescue Exception => e\n # TODO: what about ignoring the operation?\n raise e\n end\n i\n end",
"def... | [
"0.5856006",
"0.5821687",
"0.5800679",
"0.5597669",
"0.5553882",
"0.540335",
"0.5365564",
"0.5365564",
"0.5306744",
"0.5295624",
"0.52911377",
"0.52803934",
"0.5271333",
"0.5263474",
"0.52616894",
"0.5253925",
"0.52434164",
"0.52433103",
"0.51850694",
"0.5158072",
"0.51524687... | 0.0 | -1 |
Grows the set to a larger number of bits. | def grow_to_include(bit)
new_size = Math.max(@bits.attr_length << 1, num_words_to_hold(bit))
newbits = Array.typed(::Java::Long).new(new_size) { 0 }
System.arraycopy(@bits, 0, newbits, 0, @bits.attr_length)
@bits = newbits
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_bits\n bits = []\n 0.upto(63) {|i| bits << i if set?(i)}\n bits\n end",
"def set_size(nwords)\n newbits = Array.typed(::Java::Long).new(nwords) { 0 }\n n = Math.min(nwords, @bits.attr_length)\n System.arraycopy(@bits, 0, newbits, 0, n)\n @bits = newbits\n end",
"def bit... | [
"0.622211",
"0.610392",
"0.59478194",
"0.5849461",
"0.5742779",
"0.57421404",
"0.5702256",
"0.56541765",
"0.56541765",
"0.56228447",
"0.56228447",
"0.56068176",
"0.55627155",
"0.55414575",
"0.5527268",
"0.54543406",
"0.54463017",
"0.54258037",
"0.5410018",
"0.54065776",
"0.54... | 0.6301504 | 0 |
Get the first element you find and return it. Return Label.INVALID otherwise. | def get_single_element
i = 0
while i < (@bits.attr_length << LOG_BITS)
if (member(i))
return i
end
i += 1
end
return Label::INVALID
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def first\n @elements.empty? ? nil : @elements[0]\n end",
"def first\n # return value if head node is set\n if !@head.nil?\n @head.value\n else\n # otherwise raise an exception\n raise \"List is empty\"\n end\n end",
"def first_ele(class_name)\n ele_index class_name, ... | [
"0.6968261",
"0.674775",
"0.6674582",
"0.6669718",
"0.65503645",
"0.6480103",
"0.6413922",
"0.6396592",
"0.6378088",
"0.6366179",
"0.63170093",
"0.62886256",
"0.628804",
"0.6278251",
"0.62723035",
"0.624766",
"0.62473387",
"0.62420064",
"0.6231049",
"0.6217431",
"0.6189819",
... | 0.6739719 | 2 |
complement bits in the range 0..maxBit. | def not_in_place(max_bit)
not_in_place(0, max_bit)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def complement(bit)\n bit.succ % 2\n end",
"def not_in_place(min_bit, max_bit)\n # make sure that we have room for maxBit\n grow_to_include(max_bit)\n i = min_bit\n while i <= max_bit\n n = word_number(i)\n @bits[n] ^= bit_mask(i)\n i += 1\n end\n end",
... | [
"0.7735768",
"0.7006283",
"0.67882085",
"0.6254756",
"0.62417793",
"0.61749107",
"0.6017997",
"0.58112913",
"0.5759427",
"0.56757826",
"0.56259865",
"0.5619525",
"0.55927086",
"0.5579704",
"0.54644865",
"0.54485124",
"0.5395765",
"0.53838867",
"0.5356615",
"0.53327",
"0.53186... | 0.6824225 | 2 |
complement bits in the range minBit..maxBit. | def not_in_place(min_bit, max_bit)
# make sure that we have room for maxBit
grow_to_include(max_bit)
i = min_bit
while i <= max_bit
n = word_number(i)
@bits[n] ^= bit_mask(i)
i += 1
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def complement(bit)\n bit.succ % 2\n end",
"def not_in_place(max_bit)\n not_in_place(0, max_bit)\n end",
"def find_complement(num)\n result = 0\n\n num_bits = num.to_s(2).chars.map(&:to_i) # Convert to binary (base 2) and map to integers\n\n num_bits.reverse.each_with_index do |n, idx|\n ... | [
"0.73468924",
"0.64074695",
"0.6378878",
"0.61401385",
"0.608787",
"0.6007887",
"0.5979869",
"0.5874152",
"0.58718616",
"0.58137965",
"0.5782279",
"0.5641064",
"0.56012654",
"0.55617464",
"0.55020106",
"0.548051",
"0.54768574",
"0.54601836",
"0.54323894",
"0.5398898",
"0.5339... | 0.7348808 | 0 |
return this | a in a new set | def or_(a)
if ((a).nil?)
return self
end
s = self.clone
s.or_in_place(a)
return s
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_set\n ::Set.new(to_a)\n end",
"def &(other)\n # transform self into a LinkedHashSet to remove duplicates and preserve order as defined by the Ruby Array intersection contract\n duped = Java::JavaUtil::LinkedHashSet.new(self)\n duped.retainAll(other)\n duped\n end",
"def |(other)... | [
"0.61023355",
"0.59257424",
"0.58588076",
"0.5832746",
"0.58164996",
"0.5699643",
"0.5689473",
"0.5671012",
"0.5665088",
"0.5603503",
"0.5585512",
"0.55583966",
"0.5539773",
"0.55394447",
"0.5522668",
"0.55192125",
"0.5517683",
"0.5441328",
"0.5419519",
"0.5411743",
"0.538017... | 0.55396235 | 13 |
remove this element from this set | def remove(el)
n = word_number(el)
if (n >= @bits.attr_length)
grow_to_include(el)
end
@bits[n] &= ~bit_mask(el)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(obj)\n @set.removeObject obj\n end",
"def remove\n __flag__ :remove\n end",
"def remove(entry)\n @entry_set.delete(get_entry(entry))\n end",
"def remove; end",
"def remove; end",
"def remove; end",
"def remove; end",
"def remove!\n self.class.removed(item)\... | [
"0.69391745",
"0.6911127",
"0.6744244",
"0.6703757",
"0.6703757",
"0.6703757",
"0.6703757",
"0.6678802",
"0.6661913",
"0.6661913",
"0.66591704",
"0.6636542",
"0.66129375",
"0.65738076",
"0.6553057",
"0.6482025",
"0.64711875",
"0.6355289",
"0.6328037",
"0.6267222",
"0.6235042"... | 0.6754921 | 2 |
Sets the size of a set. | def set_size(nwords)
newbits = Array.typed(::Java::Long).new(nwords) { 0 }
n = Math.min(nwords, @bits.attr_length)
System.arraycopy(@bits, 0, newbits, 0, n)
@bits = newbits
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def size=(size)\n instance_set(:size, size)\n end",
"def size\n to_set.size\n end",
"def size=(value)\n @size = value\n end",
"def size=(value)\n @size = value\n end",
"def size(size)\n @value[:size] = size\n self\n ... | [
"0.68374014",
"0.6613425",
"0.6526964",
"0.6526964",
"0.6495139",
"0.6329067",
"0.628815",
"0.6287924",
"0.61458",
"0.61079127",
"0.6085733",
"0.60565335",
"0.6006084",
"0.5945788",
"0.5929795",
"0.5816402",
"0.57686806",
"0.57522374",
"0.5666391",
"0.56650144",
"0.55790687",... | 0.559628 | 20 |
return how much space is being used by the bits array not how many actually have member bits on. | def length_in_long_words
return @bits.attr_length
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def size\n (@bit_length*@length*@count)/8.0\n end",
"def size\n BitCounter.count(@val)\n end",
"def bit_set_size\n @bit_set.size\n end",
"def bit_length\n (negative? ? -self : self + ONE).log2.ceil\n end",
"def bit_length\n @bit_length ||= ECDSA.bit_length(field.prime)\n end... | [
"0.75101125",
"0.70908374",
"0.7061244",
"0.6787114",
"0.6756178",
"0.6722419",
"0.6717895",
"0.6699926",
"0.65764326",
"0.65331024",
"0.6499857",
"0.6486233",
"0.6473902",
"0.6449902",
"0.64023906",
"0.63933676",
"0.6386247",
"0.6320617",
"0.6312292",
"0.6276972",
"0.6259829... | 0.5792505 | 87 |
Is this contained within a? | def subset(a)
if ((a).nil?)
return false
end
return (self.and_(a) == self)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def contained?(other); end",
"def contained?(other); end",
"def contained?(other); end",
"def child_of?(parent); end",
"def contained_by?(kontainer)\n enclosing_containers.include?(kontainer)\n end",
"def child_of?(residue)\n residue.residue_composition.include?(self)\n end",
"def kind_of?(thin... | [
"0.7175735",
"0.7175735",
"0.7175735",
"0.70412767",
"0.70141953",
"0.6748546",
"0.66595817",
"0.66311395",
"0.66311395",
"0.65631026",
"0.6485252",
"0.64775914",
"0.6428915",
"0.6327981",
"0.6316018",
"0.63158834",
"0.6312854",
"0.6304664",
"0.6299909",
"0.6299909",
"0.62931... | 0.0 | -1 |
Subtract the elements of 'a' from 'this' inplace. Basically, just turn off all bits of 'this' that are in 'a'. | def subtract_in_place(a)
if ((a).nil?)
return
end
# for all words of 'a', turn off corresponding bits of 'this'
i = 0
while i < @bits.attr_length && i < a.attr_bits.attr_length
@bits[i] &= ~a.attr_bits[i]
i += 1
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def -(*others)\n self.dup.sub!(*others)\n end",
"def -(other)\n self & other.complement\n end",
"def -(a)\n diff = Vector.new\n self.each_index{|k| diff[k] = self[k]-a[k]}\n diff\n end",
"def -(other)\n entries - comparable(other)\n end",
"def subtract!(rhs)\n subtract ... | [
"0.6902598",
"0.6783287",
"0.66669285",
"0.66112226",
"0.6488639",
"0.6442295",
"0.6438208",
"0.6313281",
"0.625069",
"0.61773497",
"0.6151467",
"0.61400205",
"0.61400205",
"0.6126295",
"0.6089939",
"0.60820276",
"0.60635346",
"0.60316056",
"0.6028249",
"0.6013448",
"0.600436... | 0.8012475 | 0 |
Transform a bit set into a string by formatting each element as an integer separator The string to put in between elements | def to_s(g)
buf = StringBuffer.new
separator = ","
have_printed_an_element = false
buf.append(Character.new(?{.ord))
i = 0
while i < (@bits.attr_length << LOG_BITS)
if (member(i))
if (i > 0 && have_printed_an_element)
buf.append(separator)
end
if (!(g).nil?)
buf.append(g.get_token_display_name(i))
else
buf.append(i)
end
have_printed_an_element = true
end
i += 1
end
buf.append(Character.new(?}.ord))
return buf.to_s
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stringy(num, bit = 1)\n bin_arr = []\n num.times { |n| n.even? ? bin_arr << (0 + bit) : bin_arr << (1 - bit) }\n bin_arr.join\nend",
"def to_s\r\n @bitstring.reverse.scan(/.{1,8}/).map {|s| s.reverse}.reverse.map {|bin| \"\" << bin.to_i(2)}.join\r\n end",
"def show_binstring()\n @va... | [
"0.65705204",
"0.63952446",
"0.62367845",
"0.61964184",
"0.6094241",
"0.6086541",
"0.60073143",
"0.5998899",
"0.59159476",
"0.58926916",
"0.58800155",
"0.587191",
"0.5865218",
"0.58633095",
"0.5825253",
"0.5810091",
"0.5789492",
"0.57259554",
"0.56691533",
"0.5641682",
"0.562... | 0.0 | -1 |
Create a string representation where instead of integer elements, the ith element of vocabulary is displayed instead. Vocabulary is a Vector of Strings. separator The string to put in between elements | def to_s(separator, vocabulary)
if ((vocabulary).nil?)
return to_s(nil)
end
str = ""
i = 0
while i < (@bits.attr_length << LOG_BITS)
if (member(i))
if (str.length > 0)
str += separator
end
if (i >= vocabulary.size)
str += "'" + RJava.cast_to_string(RJava.cast_to_char(i)) + "'"
else
if ((vocabulary.get(i)).nil?)
str += "'" + RJava.cast_to_string(RJava.cast_to_char(i)) + "'"
else
str += RJava.cast_to_string(vocabulary.get(i))
end
end
end
i += 1
end
return str
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_s(separator=\":\")\n return self.to_a.collect {|x| x.to_s.rjust(2).gsub(/ /, \"0\")}.join(\":\")\n end",
"def humanize_list terms, separator: ', ', conjunction: ' and '\n *all_but_last, last = terms\n return last if all_but_last.empty?\n\n [ all_but_last.join(separator), last ].join conjuncti... | [
"0.53777874",
"0.53327453",
"0.52480674",
"0.52415013",
"0.51935035",
"0.5172291",
"0.5128371",
"0.51173854",
"0.5090287",
"0.50711614",
"0.50691605",
"0.5051663",
"0.50398797",
"0.5031539",
"0.5009744",
"0.5007542",
"0.5006006",
"0.50013644",
"0.4922791",
"0.49165013",
"0.49... | 0.7126704 | 0 |
Dump a commaseparated list of the words making up the bit set. Split each 64 bit number into two more manageable 32 bit numbers. This generates a commaseparated list of C++like unsigned long constants. | def to_string_of_half_words
s = StringBuffer.new
i = 0
while i < @bits.attr_length
if (!(i).equal?(0))
s.append(", ")
end
tmp = @bits[i]
tmp &= 0xffffffff
s.append(tmp)
s.append("UL")
s.append(", ")
tmp = @bits[i] >> 32
tmp &= 0xffffffff
s.append(tmp)
s.append("UL")
i += 1
end
return s.to_s
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_string_of_words\n s = StringBuffer.new\n i = 0\n while i < @bits.attr_length\n if (!(i).equal?(0))\n s.append(\", \")\n end\n s.append(@bits[i])\n s.append(\"L\")\n i += 1\n end\n return s.to_s\n end",
"def dump_memory_list\r\n lis... | [
"0.5892362",
"0.559535",
"0.55027044",
"0.55027044",
"0.54306203",
"0.52934587",
"0.5257748",
"0.5241507",
"0.5190763",
"0.5145993",
"0.5139401",
"0.5136722",
"0.5134747",
"0.51137364",
"0.51130307",
"0.5045035",
"0.50208795",
"0.49906358",
"0.49779785",
"0.49544388",
"0.4949... | 0.61334383 | 0 |
Dump a commaseparated list of the words making up the bit set. This generates a commaseparated list of Javalike long int constants. | def to_string_of_words
s = StringBuffer.new
i = 0
while i < @bits.attr_length
if (!(i).equal?(0))
s.append(", ")
end
s.append(@bits[i])
s.append("L")
i += 1
end
return s.to_s
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_string_of_half_words\n s = StringBuffer.new\n i = 0\n while i < @bits.attr_length\n if (!(i).equal?(0))\n s.append(\", \")\n end\n tmp = @bits[i]\n tmp &= 0xffffffff\n s.append(tmp)\n s.append(\"UL\")\n s.append(\", \")\n tmp = ... | [
"0.58315533",
"0.57714975",
"0.5598301",
"0.55260336",
"0.55224717",
"0.54917103",
"0.5437852",
"0.54302484",
"0.54260695",
"0.5402459",
"0.5402459",
"0.5370801",
"0.535706",
"0.5354086",
"0.5335332",
"0.5335332",
"0.53127104",
"0.5310909",
"0.5310909",
"0.53037834",
"0.52779... | 0.6290849 | 0 |
GET /release_loans/1 GET /release_loans/1.json | def show
@release_loan = ReleaseLoan.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.json { render json: @release_loan }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n @release_loan = ReleaseLoan.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @release_loan }\n end\n end",
"def loans\n url = \"#{LOANS_PATH}/pre-approved\"\n data = perform_get(url)\n data || {}\n end",
"de... | [
"0.65779734",
"0.64447767",
"0.61666363",
"0.61097944",
"0.60500455",
"0.60178524",
"0.601515",
"0.6006315",
"0.6006315",
"0.60000205",
"0.5974195",
"0.5943659",
"0.5926613",
"0.5922706",
"0.5915611",
"0.58959275",
"0.58763134",
"0.5850821",
"0.5830902",
"0.5820456",
"0.58078... | 0.6997902 | 0 |
GET /release_loans/new GET /release_loans/new.json | def new
@release_loan = ReleaseLoan.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @release_loan }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n @lost = Lost.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @lost }\n end\n end",
"def new\n @release = Release.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @release }\n end\n e... | [
"0.7120017",
"0.7102812",
"0.7056036",
"0.7038341",
"0.7010651",
"0.6829084",
"0.6829084",
"0.6810086",
"0.6808071",
"0.67365116",
"0.6729013",
"0.66943383",
"0.66585845",
"0.66392756",
"0.66392756",
"0.66368014",
"0.66124094",
"0.6606484",
"0.6605926",
"0.6601252",
"0.659051... | 0.7535736 | 0 |
POST /release_loans POST /release_loans.json | def create
@release_loan = ReleaseLoan.new(params[:release_loan])
respond_to do |format|
if @release_loan.save
format.html { redirect_to @release_loan, notice: 'Release loan was successfully created.' }
format.json { render json: @release_loan, status: :created, location: @release_loan }
else
format.html { render action: "new" }
format.json { render json: @release_loan.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n @release_loan = ReleaseLoan.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @release_loan }\n end\n end",
"def loans\n url = \"#{LOANS_PATH}/pre-approved\"\n data = perform_get(url)\n data || {}\n end",
"de... | [
"0.6025203",
"0.5773867",
"0.5728883",
"0.5720152",
"0.5634739",
"0.5584936",
"0.5515859",
"0.5504758",
"0.55025077",
"0.5491573",
"0.5488336",
"0.54790246",
"0.5446512",
"0.5418494",
"0.5416051",
"0.53619957",
"0.5348527",
"0.53414464",
"0.5328799",
"0.52890575",
"0.52852386... | 0.66710174 | 0 |
PUT /release_loans/1 PUT /release_loans/1.json | def update
@release_loan = ReleaseLoan.find(params[:id])
respond_to do |format|
if @release_loan.update_attributes(params[:release_loan])
format.html { redirect_to @release_loan, notice: 'Release loan was successfully updated.' }
format.json { head :no_content }
else
format.html { render action: "edit" }
format.json { render json: @release_loan.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @release_loan = ReleaseLoan.new(params[:release_loan])\n\n respond_to do |format|\n if @release_loan.save\n format.html { redirect_to @release_loan, notice: 'Release loan was successfully created.' }\n format.json { render json: @release_loan, status: :created, location: @rele... | [
"0.609197",
"0.5708468",
"0.5613374",
"0.55026466",
"0.5499115",
"0.54883105",
"0.5460921",
"0.54535025",
"0.5446856",
"0.5441261",
"0.53988326",
"0.5381921",
"0.53722507",
"0.5350656",
"0.5334729",
"0.53315985",
"0.5296379",
"0.5296379",
"0.5291428",
"0.5290996",
"0.5288257"... | 0.63873297 | 0 |
DELETE /release_loans/1 DELETE /release_loans/1.json | def destroy
@release_loan = ReleaseLoan.find(params[:id])
@release_loan.destroy
respond_to do |format|
format.html { redirect_to release_loans_url }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_aos_version(args = {}) \n delete(\"/aosversions.json/#{args[:aosVersionId]}\", args)\nend",
"def delete_tenant_circle(args = {}) \n delete(\"/tenantcircles.json/#{args[:circleId]}\", args)\nend",
"def destroy\n @client_release = ClientRelease.find(params[:id])\n @client_release.destroy\n\n ... | [
"0.7100835",
"0.6832401",
"0.672356",
"0.6696524",
"0.66841304",
"0.6681314",
"0.6584477",
"0.6582933",
"0.6579868",
"0.6565128",
"0.65610313",
"0.6549521",
"0.65331197",
"0.65145177",
"0.6507528",
"0.64937526",
"0.647958",
"0.6479154",
"0.64726716",
"0.64711344",
"0.6467382"... | 0.72731197 | 0 |
Return a list of breadcrumbs appropriate for the particular controller. This method can be overridden by any specific subclass to introduce sublinks into the breadcrumb path. A leaf path can then be introduced by the local controller by convention using local code | def breadcrumbs
@breadcrumbs
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def individual_breadcrumb\n add_breadcrumb \"Clients\", clients_path, :title => \"Clients\" \n add_breadcrumb \"Power Of Attorney\", '', :title => \"Power Of Attorney\" \n add_breadcrumb \"Principal Create\", '', :title => \"Principal Create\"\n end",
"def breadcrumbs() [] end",
"def hardcoded_brea... | [
"0.735429",
"0.7180779",
"0.7159015",
"0.70273346",
"0.70001906",
"0.69109005",
"0.6785538",
"0.67476326",
"0.6741683",
"0.66939044",
"0.66196",
"0.6616654",
"0.65914285",
"0.659079",
"0.6581506",
"0.6562057",
"0.6552254",
"0.650586",
"0.650586",
"0.6495125",
"0.6448991",
"... | 0.6453565 | 21 |
Root breadcrumbs setup method. May be overridden or augmented by subclasses | def set_breadcrumbs
@breadcrumbs = []
add_breadcrumb "Home", root_path
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def auto_set_breadcrumb\n ariane.add(\"Home\", root_path, 1) if ariane.crumbs.empty? \n \n if self.action_name == \"index\"\n name = controller_name.titleize\n level = get_level || 2\n else\n name = \"#{action_name.titleize} #{controller_name.singularize.titleize}\"\n ... | [
"0.7122897",
"0.69954604",
"0.69638413",
"0.6900299",
"0.68838817",
"0.6865224",
"0.67939645",
"0.67313737",
"0.6623273",
"0.65754205",
"0.65553534",
"0.6537324",
"0.65344507",
"0.652361",
"0.65156025",
"0.648781",
"0.648781",
"0.6337952",
"0.63268906",
"0.6270689",
"0.62135"... | 0.7764661 | 1 |
Add a single link's data in a hash | def add_breadcrumb title, link = nil
if link.nil?
@breadcrumbs << { :title => title }
else
@breadcrumbs << { :title => title, :link => link }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(hash); end",
"def update_link!(link)\n key = link.key\n val = link.val\n @store.remove(key)\n link = @store.append(key,val) #this is where you move the link to end of list\n @map[key] = link\n end",
"def add_hash(id, hash, source)\n @hashes[id] = {:deletehash => hash, :source => s... | [
"0.6917243",
"0.64350635",
"0.6405165",
"0.63147473",
"0.61907256",
"0.61576253",
"0.6153634",
"0.61535573",
"0.6138766",
"0.61183774",
"0.6100849",
"0.60820377",
"0.60476077",
"0.5986283",
"0.5972581",
"0.58279985",
"0.58270067",
"0.5826206",
"0.57946",
"0.5779864",
"0.57703... | 0.0 | -1 |
Only call find_record in a before_filter for methods that should have an id or record_id parameter. Make sure to add exceptions for methods that don't. | def find_record
record_id = params[:record_id] || params[:id]
@record = Record.where(medical_record_number: record_id).first
not_found if @record.nil?
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_record_by(model)\n raise_must_override\n end",
"def find_record_with_callbacks\n run_callbacks(:before_find)\n result = find_record_without_callbacks\n run_callbacks(:after_find) if result\n result\n end",
"def find_record\n @record ||= model.find_by_id(params... | [
"0.6547426",
"0.65013653",
"0.6427717",
"0.6388251",
"0.61578214",
"0.6005255",
"0.59636873",
"0.5933331",
"0.5920814",
"0.59071034",
"0.5800616",
"0.57630265",
"0.57583976",
"0.57572025",
"0.57572025",
"0.5708516",
"0.5683091",
"0.56695384",
"0.5663121",
"0.5562514",
"0.5537... | 0.62377965 | 4 |
Track each controller and method (action) call | def audit_log_all
if params[:controller] && params[:action]
desc = params[:controller] + "|" + params[:action]
desc << "|id:#{params[:id]}" if params[:id]
## log user email for now
## TODO: change to larger requester info set
if current_user
if desc =~ /sessions\|destroy/
desc << "|LOGOUT"
end
AuditLog.create(requester_info: current_user.email, event: "USER_ACTION", description: desc)
else
AuditLog.create(requester_info: "NONE", event: "USER_ACTION", description: desc)
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def track_action\n unless ENV['DISABLE_TRACKING'] == 'true'\n ahoy.track \"#{controller_name}##{action_name}\", request.filtered_parameters\n end\n end",
"def process_action(method_name, *args); end",
"def action_methods; end",
"def action_methods; end",
"def action_methods; end",
"de... | [
"0.6284122",
"0.62591183",
"0.61800784",
"0.61800784",
"0.61800784",
"0.6156427",
"0.60583436",
"0.60583436",
"0.60583436",
"0.60486376",
"0.5987287",
"0.59843",
"0.59843",
"0.59843",
"0.59843",
"0.59843",
"0.59843",
"0.59843",
"0.59843",
"0.59843",
"0.59843",
"0.59035766",... | 0.553982 | 55 |
Log action, along with record_id, section, and id from params, plus any optional params (which overwrite the default params if there are duplicates) | def audit_log(action, optional_params = {})
description = params.slice(:record_id, :section, :id).merge(optional_params).map { |key, value| "#{key}:#{value}"}.join('|')
requester = current_user.try(:email) || 'NONE'
AuditLog.create(event: action, description: description, requester_info: requester)
description
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def record(action, *arguments)\n log \"#{action_padding(action)}#{action} #{arguments.join(' ')}\"\n end",
"def log_action(action, user, record, model)\n begin\n # Create a new ActionLog Object\n event = ActionLog.new()\n \n # Add the user to this object\n event.user = user\n ... | [
"0.69043815",
"0.6187379",
"0.61687094",
"0.6154826",
"0.6057162",
"0.6057162",
"0.6009562",
"0.59668994",
"0.5951249",
"0.5904017",
"0.582372",
"0.58196425",
"0.5728946",
"0.5704486",
"0.5697666",
"0.5654343",
"0.56509435",
"0.5620393",
"0.56200576",
"0.55629987",
"0.5551833... | 0.7261586 | 0 |
Check the accepts header and defaults the format to request an atom feed apply to a controller using a before filter | def default_format_to_atom
# Default the type we are sending out
if request.accept.nil?
request.format = :atom
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_accept_header!\n return if request.headers[\"Accept\"] == \"application/vnd.api+json\"\n\n error!(\"415 Unsupported Media Type\", 415)\n end",
"def accept_header(request)\n raise NotImplementedError\n end",
"def default_filters!\n before do\n request.path_info =~ ... | [
"0.63195884",
"0.6160523",
"0.60867524",
"0.6040874",
"0.591975",
"0.58592826",
"0.58361834",
"0.5788255",
"0.5686055",
"0.56823987",
"0.5674783",
"0.566768",
"0.5658958",
"0.5650856",
"0.56197417",
"0.56192154",
"0.5457011",
"0.5438114",
"0.54233116",
"0.54086673",
"0.540389... | 0.5788159 | 9 |
Use callbacks to share common setup or constraints between actions. | def set_milestone
@milestone = Milestone.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 milestone_params
params.require(:milestone).permit(:heading, :when, :what, :picture)
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 |
input: array of integers output: array containing running total for each element data structure: integer array algorithim: initialise `sum` equal to `0` initialise `running_total` empty array iterate over array argument increment `sum` by current element append `sum` to `running_total` return `running_total` Examples: | def running_total(array)
sum = 0
running_total = []
array.each do |element|
sum += element
running_total << sum
end
running_total
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def running_total arr\n totals = []\n sum = 0\n arr.each do |elm|\n sum += elm\n totals << sum\n end\n totals\nend",
"def running_total(array)\n sum = 0\n array.each_with_object([]) do |el, new_array|\n new_array << sum += el\n end\nend",
"def running_total(arr)\n res = []\n running_total = ... | [
"0.88819605",
"0.8881816",
"0.87973315",
"0.87761205",
"0.87680596",
"0.87643987",
"0.8719478",
"0.871287",
"0.8707647",
"0.8707366",
"0.86850494",
"0.868466",
"0.868466",
"0.868466",
"0.86779493",
"0.86539716",
"0.862774",
"0.86248994",
"0.86165947",
"0.8607811",
"0.8600865"... | 0.8890326 | 0 |
initialize a resource instance | def initialize(object, response = nil)
@object = object
@amount = object['amount']
@arrival_date = object['arrival_date']
@created_at = object['created_at']
@currency = object['currency']
@deducted_fees = object['deducted_fees']
@id = object['id']
@links = object['links']
@reference = object['reference']
@status = object['status']
@response = response
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(resource)\n @resource = resource\n end",
"def initialize(resource)\n @resource = resource\n end",
"def initialize(resource)\n @resource = resource\n end",
"def initialize args = {}\n self.resource = args[:resource] || ''\n end",
"def initialize(resource, embed... | [
"0.820891",
"0.8153959",
"0.8115135",
"0.7480056",
"0.738973",
"0.7347292",
"0.7278875",
"0.72060287",
"0.71424425",
"0.71415067",
"0.7141086",
"0.7135027",
"0.7111583",
"0.71081305",
"0.70504045",
"0.7020879",
"0.7020879",
"0.7014208",
"0.6995968",
"0.69896716",
"0.69896716"... | 0.0 | -1 |
return the links that the resource has | def links
valid_link_keys = %w(creditor creditor_bank_account )
valid_links = (@links || {}).select { |key, _| valid_link_keys.include?(key) }
links_class = Struct.new(
*{
creditor: '',
creditor_bank_account: ''
}.keys
) do
def initialize(hash)
hash.each do |key, val|
send("#{key}=", val)
end
end
end
links_class.new(valid_links)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def links\n return @links\n end",
"def links\n return @links\n end",
"def links\n return @links\n end",
"def links()\n return @links\n end",
"def links\n @data[\"_links\"]\n end",
"def links\n @links ||= []\n ... | [
"0.8133294",
"0.8133294",
"0.8133294",
"0.8021847",
"0.7828761",
"0.77440953",
"0.77269757",
"0.77112144",
"0.77112144",
"0.7706865",
"0.7706132",
"0.7706132",
"0.7652742",
"0.7626881",
"0.7626881",
"0.7626881",
"0.76182514",
"0.75561905",
"0.7470416",
"0.746724",
"0.7419365"... | 0.0 | -1 |
Provides the resource as a hash of all it's readable attributes | def to_h
@object
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resource_attributes\n resource_class.attribute_names\n end",
"def resource_attributes\n @resource_attributes ||= Marshal.load(Marshal.dump(self.class.resource_attributes))\n end",
"def resource_attributes\n %w(\n auth_users\n comment\n dont_compress\n ... | [
"0.7515443",
"0.74780005",
"0.7380335",
"0.71874815",
"0.7178696",
"0.70274407",
"0.69656104",
"0.69656104",
"0.69656104",
"0.690871",
"0.68827474",
"0.68781734",
"0.6804732",
"0.6794832",
"0.67628634",
"0.67628634",
"0.6748658",
"0.6733451",
"0.66991216",
"0.6682305",
"0.662... | 0.0 | -1 |
GET /feed_entries GET /feed_entries.xml | def index
@project = Project.find(params[:project_id])
#depending if I am showing all entries or only the persons entries.
@count = 0
if params[:person_id] == nil
@show_all = true
@feed_entries = []
@grouped_entries = []
@grouped_by_hashtags = {}
@grouped_by_replies = {}
@grouped_urls = {}
@feed_entries_count = @project.feed_entries_count
@feed_entries = @project.feed_entries(1000).paginate :page => params[:page]
#Get a distribution of collected tweets per person.
@feed_entries_pp = {}
@project.persons.each do |person|
key = (FeedEntry.count(:conditions => "person_id = #{person.id}") / 100).to_i*100
begin
@feed_entries_pp[key] += 1
rescue
@feed_entries_pp[key] = 1
end
end
@feed_entries_pp = @feed_entries_pp.sort{|a,b| a <=> b}
@retweets_distr = {}
@project.persons.each do |person|
person.feed_entries.each do |f|
key = f.retweet_count.to_i
if key > 0
begin
@retweets_distr[key] += 1
rescue
@retweets_distr[key] = 1
end
end
end
end
@retweets_distr = @retweets_distr.sort{|a,b| a <=> b}
else
@person = Person.find(params[:person_id])
@feed_entries_count = @person.feed_entries.count
@feed_entries = @person.feed_entries.paginate :page => params[:page], :order => 'updated_at DESC'
end
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @feed_entries }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n #body, ok = SuperfeedrEngine::Engine.retrieve(Feed.first) \n @entries = Entry.all\n end",
"def rss_entries(url)\n\t\tresponse = fetch(url)\n\t\tresponse[\"feed\"][\"entry\"]\n\tend",
"def index\n @feed_entries = FeedEntry.all\n @title = \"Feeds List\"\n respond_to do |format|\n ... | [
"0.7467509",
"0.739195",
"0.73252153",
"0.72314",
"0.7188785",
"0.7104639",
"0.7060942",
"0.6975196",
"0.6948779",
"0.69036674",
"0.6880097",
"0.68380207",
"0.6771395",
"0.6732317",
"0.6727265",
"0.67201823",
"0.67142063",
"0.669728",
"0.66721797",
"0.6670565",
"0.6658709",
... | 0.0 | -1 |
GET /feed_entries/1 GET /feed_entries/1.xml | def show
@feed_entry = FeedEntry.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @feed_entry }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n #body, ok = SuperfeedrEngine::Engine.retrieve(Feed.first) \n @entries = Entry.all\n end",
"def index\n @feed_entries = FeedEntry.all\n @title = \"Feeds List\"\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @feed_entries }\n end\n e... | [
"0.7315541",
"0.7226129",
"0.71670896",
"0.699796",
"0.6963212",
"0.6870064",
"0.6869342",
"0.6830619",
"0.6771149",
"0.67504215",
"0.67402446",
"0.67401975",
"0.6735528",
"0.6722902",
"0.6682149",
"0.6673443",
"0.66433555",
"0.65687394",
"0.6559264",
"0.6558318",
"0.65565",
... | 0.70647407 | 3 |
GET /feed_entries/new GET /feed_entries/new.xml | def new
@feed_entry = FeedEntry.new
@project = Project.find(params[:project_id])
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @feed_entry }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n @feed = Feed.find(params[:feed_id])\n @entry = @feed.entries.new\n respond_to do |format|\n format.html { render :layout => 'feed'}\n format.json { render json: @entry }\n end\n end",
"def new\n @twitterfeed = Twitterfeed.new\n\n respond_to do |format|\n format.html # ... | [
"0.7611285",
"0.73625153",
"0.7323835",
"0.7213086",
"0.7202514",
"0.71984553",
"0.71972966",
"0.7179313",
"0.715861",
"0.7147235",
"0.7035788",
"0.7035788",
"0.7035788",
"0.7035788",
"0.7027598",
"0.6977427",
"0.6977197",
"0.6947543",
"0.6944234",
"0.6910501",
"0.6795124",
... | 0.7042938 | 10 |
POST /feed_entries POST /feed_entries.xml | def create
@feed_entry = FeedEntry.new(params[:feed_entry])
respond_to do |format|
if @feed_entry.save
flash[:notice] = 'FeedEntry was successfully created.'
format.html { redirect_to(@feed_entry) }
format.xml { render :xml => @feed_entry, :status => :created, :location => @feed_entry }
else
format.html { render :action => "new" }
format.xml { render :xml => @feed_entry.errors, :status => :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @feed = Feed.find(params[:feed_id])\n @entry = @feed.entries.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n @entry.author.save\n format.html { redirect_to feed_entry_path(@feed,@entry), notice: 'Entry was successfully created.' }\n format.json { re... | [
"0.65413153",
"0.64110947",
"0.63338536",
"0.632252",
"0.6309666",
"0.6291664",
"0.6263487",
"0.62322825",
"0.6198932",
"0.61660373",
"0.61660373",
"0.61660373",
"0.61660373",
"0.61290556",
"0.61201435",
"0.61101353",
"0.6048387",
"0.60270894",
"0.5977057",
"0.5966648",
"0.59... | 0.6461824 | 1 |
Gather all rss for a given person | def collect_all_entries
person = Person.find(params[:id])
Delayed::Job.enqueue(CollectAllFeedEntriesJob.new(person.id))
respond_to do |format|
format.js do
render :update do |page|
flash[:notice] = 'FeedEntries will be collected. Around ' + person.statuses_count.to_s + ' Feed entries will be gathered.'
page.reload
end
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_entries\n @feed_entries = FeedEntry.find(:all, :conditions => { :person_id => self.id}, :order => 'published_at DESC')\n end",
"def get_userposts( user )\n posts = []\n url = \"http://feeds.delicious.com/rss/#{user}\"\n\n response = Net::HTTP.get_response(URI.parse(url)).body\n doc =... | [
"0.6419823",
"0.63037336",
"0.6288876",
"0.6203973",
"0.6202745",
"0.61862034",
"0.61345345",
"0.6106263",
"0.60801655",
"0.6079445",
"0.6059792",
"0.6058583",
"0.6056247",
"0.60481274",
"0.59819645",
"0.59747136",
"0.5969957",
"0.595181",
"0.5950664",
"0.59069204",
"0.589563... | 0.0 | -1 |
PUT /feed_entries/1 PUT /feed_entries/1.xml | def update
@feed_entry = FeedEntry.find(params[:id])
respond_to do |format|
if @feed_entry.update_attributes(params[:feed_entry])
flash[:notice] = 'FeedEntry was successfully updated.'
format.html { redirect_to(@feed_entry) }
format.xml { head :ok }
else
format.html { render :action => "edit" }
format.xml { render :xml => @feed_entry.errors, :status => :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @entry = Entry.find(params[:id])\n @feed = @entry.feed\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to feed_entry_path(@feed, @entry), notice: 'Entry was successfully updated.' }\n format.json { head :no_content }\n ... | [
"0.67380095",
"0.67380095",
"0.6557836",
"0.6528169",
"0.648896",
"0.63349605",
"0.63323367",
"0.6322824",
"0.63155645",
"0.62967324",
"0.6288994",
"0.6286226",
"0.6272155",
"0.6272155",
"0.6268469",
"0.62657356",
"0.62527204",
"0.621444",
"0.6198579",
"0.6171512",
"0.6169135... | 0.6570691 | 2 |
DELETE /feed_entries/1 DELETE /feed_entries/1.xml | def destroy
@feed_entry = FeedEntry.find(params[:id])
@feed_entry.destroy
respond_to do |format|
format.html { redirect_to(feed_entries_url) }
format.xml { head :ok }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @entry = Entry.find(params[:id])\n @feed = @entry.feed\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to feed_path(@feed) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed = Feed.find(params[:id])\n @feed.destroy\n\n res... | [
"0.71579355",
"0.7028766",
"0.70177007",
"0.6973815",
"0.6934134",
"0.6934134",
"0.6934134",
"0.6934134",
"0.6934134",
"0.6912192",
"0.69084364",
"0.690329",
"0.6856918",
"0.68258643",
"0.6805577",
"0.6785518",
"0.67805064",
"0.6753707",
"0.67425853",
"0.6725857",
"0.6715022"... | 0.74111605 | 0 |
redirect to this page after login | def after_sign_in_path_for(resource)
"/users/#{current_user.id}"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def redirect_to_login_page\n query_params = request.query_parameters\n query_params.merge!(return_to: request.path)\n\n target = cms_path(Homepage.default.login_page, query_params)\n\n redirect_to(target, alert: \"This page is protected. You either don't have neccessary access rights or you are not log... | [
"0.79045576",
"0.7693476",
"0.7462141",
"0.7453687",
"0.743246",
"0.7416154",
"0.74111325",
"0.7382886",
"0.7381028",
"0.7375426",
"0.73032147",
"0.73026556",
"0.7302096",
"0.7283289",
"0.7267689",
"0.7192323",
"0.7184192",
"0.7184189",
"0.7179869",
"0.7157843",
"0.7147419",
... | 0.0 | -1 |
Laptops fleet_type Can be: :all, :spares, :staff, :archived Return a table of inwarranty laptops. | def print_laptops(fleet_type)
simple_print(@snipe.laptops(fleet_type), %w(asset_tag serial name assigned_to.username), 'asset_tag', ['Asset Tag', 'Serial', 'Asset Name', 'Assigned To'])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_laptops_in_warranty(fleet_type)\n laptops = @snipe.laptops(fleet_type)\n data = laptops.find_all {|i| i['in_warranty'] }\n simple_print(data, %w(warranty_expires.formatted asset_tag serial name assigned_to.username), 'warranty_expires.formatted', ['Warranty Expires', 'Asset Tag', 'Serial', 'Asse... | [
"0.70259136",
"0.53149456",
"0.515949",
"0.5121093",
"0.50394136",
"0.5028877",
"0.501755",
"0.49732032",
"0.48626444",
"0.48626444",
"0.4861469",
"0.48566943",
"0.48566943",
"0.48486102",
"0.48301536",
"0.4811267",
"0.4800878",
"0.47946212",
"0.47769666",
"0.47404608",
"0.47... | 0.6492 | 1 |
Return a table of inwarranty laptops. | def print_laptops_in_warranty(fleet_type)
laptops = @snipe.laptops(fleet_type)
data = laptops.find_all {|i| i['in_warranty'] }
simple_print(data, %w(warranty_expires.formatted asset_tag serial name assigned_to.username), 'warranty_expires.formatted', ['Warranty Expires', 'Asset Tag', 'Serial', 'Asset Name', 'Assigned To'])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @warranties = Warranty.all\n\n end",
"def working_items_table\n contract_info_tables = page.all(\"table.table-hover.table-bordered.table-striped\", visible: true)\n unless contract_info_tables[1].nil?\n return Helpers::OpsUiHelper::TableHelper.new(node: contract_info_tables[1])\n en... | [
"0.5743786",
"0.5688127",
"0.5435192",
"0.5398771",
"0.5393867",
"0.5357076",
"0.52888983",
"0.5271688",
"0.523566",
"0.5212356",
"0.5120372",
"0.51030827",
"0.50963885",
"0.50513303",
"0.50475675",
"0.50425494",
"0.5040569",
"0.50213844",
"0.5014964",
"0.50043285",
"0.499424... | 0.6875968 | 0 |
Return a table of laptops sorted by age. Age is approximate. This method does not calculate the intricacies of leap years, etc. | def print_laptops_by_age(fleet_type, older_than_years = 0.0)
laptops = @snipe.laptops(fleet_type)
older_than_years = older_than_years.to_f
data = []
# Do not include these very old assets if filtering by age
if older_than_years == 0.0
# Format assets that have word based asset_tags, such as 'oldspare03'
data += laptops.find_all {|i| asset_tag_type(i['asset_tag']) == 'word-based' }
.sort_by {|i| i['asset_tag'] }
.map {|i| ['---', '---', i['asset_tag'], i['serial'], i['name']] }
# Format assets that are so old the asset_tags increment from '000000001' and up
data += laptops.find_all {|i| asset_tag_type(i['asset_tag']) == 'incremental' }
.sort_by {|i| i['asset_tag'] }
.map {|i| ['---', '---', i['asset_tag'], i['serial'], i['name']] }
end
# Format assets that have date-based asset_tags (default asset_tag structure)
date_asset_tags = laptops.find_all {|i| asset_tag_type(i['asset_tag']) == 'date-based' }
# Filter date-based asset_tags based on approx age
if older_than_years != 0.0
date_asset_tags = date_asset_tags.find_all {|i| calculate_asset_age(i['asset_tag']) >= older_than_years }
end
data += date_asset_tags.sort_by {|i| i['asset_tag'] }
.map {|i| [Date.parse(i['asset_tag']).strftime('%Y-%m-%d'), calculate_asset_age(i['asset_tag']), i['asset_tag'], i['serial'], i['name']] }
@printer.print_table(data, ['Purchase Date', 'Approx Age', 'Asset Tag', 'Serial', 'Asset Name'])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sorted_by_age(people)\nend",
"def index\n @laws = Law.order(cached_votes_up: :desc).each\n end",
"def sort_tenants_by_age tenants\n return tenants.sort_by { |tenant| tenant.age }\n end",
"def elements_sorted_by_experience\n collection.sort_by{|person| person[:years_experience]}\n end",
"def... | [
"0.65759236",
"0.5627051",
"0.55942386",
"0.5504107",
"0.53523934",
"0.523864",
"0.52038014",
"0.5146799",
"0.51239246",
"0.5108985",
"0.5104057",
"0.50993574",
"0.50917935",
"0.5044814",
"0.50363946",
"0.50363946",
"0.50363946",
"0.5031838",
"0.50164354",
"0.5011932",
"0.500... | 0.6540366 | 1 |
Returns the PepCharges structure | def charge_at_pH(pep_charges, pH)
charge = 0
charge += -1/(1+10**(pep_charges.c_term-pH))
charge += -pep_charges.d_num/(1+10**(ResidueTable[:D][2]-pH))
charge += -pep_charges.e_num/(1+10**(ResidueTable[:E][2]-pH))
charge += -pep_charges.c_num/(1+10**(ResidueTable[:C][2]-pH))
charge += -pep_charges.y_num/(1+10**(ResidueTable[:Y][2]-pH))
charge += 1/(1+10**(pH - pep_charges.n_term))
charge += pep_charges.h_num/(1+10**(pH-ResidueTable[:H][2]))
charge += pep_charges.k_num/(1+10**(pH-ResidueTable[:K][2]))
charge += pep_charges.r_num/(1+10**(pH-ResidueTable[:R][2]))
charge
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_charge\n @charge\n end",
"def recurring_charges\n data.recurring_charges\n end",
"def generation_charges\n [ [{ :content => \"Current Supplier: THE FLYING BLINKY LIGHTS COMPANY\", :colspan => 4 }],\n [\"Generation Service Charge\", \"491 kWh X $.090041\", \"$\", \"44.21\"],\n [... | [
"0.6529873",
"0.6190628",
"0.5827379",
"0.57522726",
"0.5734278",
"0.5733032",
"0.56134707",
"0.5567212",
"0.5564163",
"0.5486686",
"0.5440201",
"0.5439533",
"0.5439533",
"0.54135835",
"0.54127526",
"0.5376896",
"0.5346125",
"0.5345998",
"0.5302205",
"0.5269249",
"0.52488494"... | 0.60143906 | 2 |
This is to fix a bug in Rails. 1.2.2 was calling klass.controller_name instead of klass.controller_path, which was in turn setting the params[:controller] => "contacts", instead of params[:controller] => "two/contact". Submitted ticket 7545 Namespaces only supported in ActiveScaffold with Rails 1.2.2 | def component_response(options, reuse_response)
klass = component_class(options)
request = request_for_component(klass.controller_path, options)
new_response = reuse_response ? response : response.dup
klass.process_with_components(request, new_response, self)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def namespace\n # controller_name_segments = params[:controller].split('/')\n # controller_name_segments.pop\n # controller_name_segments.join('/').camelize\n params[:controller].split('/').first\n end",
"def controller_name\n \"#{self.class.app_namespace}::#{@controller_name}\"\n end",
"def n... | [
"0.7260509",
"0.71184236",
"0.70100814",
"0.6826947",
"0.6783166",
"0.6699138",
"0.6649088",
"0.6649088",
"0.66461784",
"0.6632181",
"0.6614491",
"0.6558352",
"0.65506977",
"0.6525755",
"0.6524968",
"0.65139276",
"0.63646674",
"0.63646674",
"0.63380075",
"0.6337231",
"0.63202... | 0.0 | -1 |
this is diffrent to the instance method create_or_update | def update_or_create(attributes = {})
id = attributes.delete(:id)
conditions = attributes.delete(:conditions)
returning (id && find_by_id(id)) || find(:first, :conditions => conditions) || new do |record|
attributes.each_pair { |key, value| record[key] = value }
record.save
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n create_or_update\n end",
"def create\n create_or_update\n end",
"def update\n create_or_update\n end",
"def save\n create_or_update\n end",
"def create_or_update\n raise ReadOnlyRecord if readonly?\n result = new_record? ? create_record : update_record\n re... | [
"0.81713086",
"0.81713086",
"0.81512535",
"0.7520768",
"0.7459172",
"0.74160856",
"0.7342664",
"0.7342664",
"0.7342664",
"0.73213065",
"0.70959055",
"0.709103",
"0.70824456",
"0.7055663",
"0.70391387",
"0.6947198",
"0.6946821",
"0.69423205",
"0.68895113",
"0.6887544",
"0.6868... | 0.60693043 | 95 |
Allows the gem to be configured | def configure
yield(config) if block_given?
config
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def configure; end",
"def install_gem; end",
"def gemspec?; end",
"def require_gems; end",
"def setup_config\n # To be Extended\n end",
"def gemspec; end",
"def gemspec; end",
"def gemspec; end",
"def gemspec; end",
"def gemspec; end",
"def gemspec; end",
"def gemspec; end",
"def ge... | [
"0.6814476",
"0.66954845",
"0.66918427",
"0.66785383",
"0.6674751",
"0.6632062",
"0.6632062",
"0.6632062",
"0.6632062",
"0.6632062",
"0.6632062",
"0.6632062",
"0.6632062",
"0.662885",
"0.66278076",
"0.6542451",
"0.6458468",
"0.6432698",
"0.6419545",
"0.641434",
"0.6381914",
... | 0.0 | -1 |
The current version of the gem | def version
VERSION
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def current_version\n @version\n end",
"def current_version\n version_number rev\n end",
"def gem_version; end",
"def gem_version; end",
"def gem_version; end",
"def gem_version; end",
"def gem_version; end",
"def gem_version; end",
"def current_version\n versions.first\n end",
"def g... | [
"0.8402233",
"0.8285564",
"0.81663257",
"0.81663257",
"0.81663257",
"0.81663257",
"0.81663257",
"0.81663257",
"0.8029159",
"0.7997906",
"0.7979759",
"0.79535353",
"0.7936448",
"0.7897763",
"0.7861538",
"0.7845943",
"0.7814506",
"0.774655",
"0.7740761",
"0.7728233",
"0.7702164... | 0.78463966 | 16 |
Delete any old channel requests (since they were approved) | def destroy_channel_request
channel_request = ChannelRequest.where(:user_id => self.subscriber_id, :channel_id => self.channel_id).first
channel_request.destroy unless channel_request.blank?
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_requests\n self.requests.each {|request| request.destroy}\n end",
"def delete_old_requests\n Request.where('created_at < ?', Time.now - 15.minutes).delete_all\n end",
"def remove_all_requests\n return if params[:request_ids].blank?\n requests = params[:request_ids].split(',')\n requ... | [
"0.70704406",
"0.64151096",
"0.614683",
"0.6117218",
"0.60943437",
"0.5942399",
"0.5942253",
"0.5922376",
"0.59148246",
"0.5883685",
"0.5854346",
"0.58487946",
"0.58487946",
"0.5841473",
"0.58020866",
"0.5789247",
"0.57869005",
"0.5782026",
"0.57478416",
"0.5705308",
"0.57034... | 0.67095536 | 1 |
"Ths wbst s fr lsrs LL!" | def remove_vowels(sentence)
sentence.split.map{|word| word.delete"aeiouyAEIOUY"}.join(" ")
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def whisper(phrase)\n return \"#{phrase.downcase}...shhhhhhh\"\nend",
"def s_th(string)\r\n th_ify = string.chars.map { |x| x == \"s\" ? 'th' : x }\r\n return th_ify.join\r\nend",
"def hackerSpeak(word)\n\tnew_word=''\n\tword.each_char do |c|\n\t\tif c.downcase=='a'\n\t\t\tnew_word=new_word+'4'\n\t\te... | [
"0.71006894",
"0.69764805",
"0.64551115",
"0.64450234",
"0.639241",
"0.6364488",
"0.63452524",
"0.6292778",
"0.6260079",
"0.6232344",
"0.62132955",
"0.6201864",
"0.6184731",
"0.6179645",
"0.6178445",
"0.61596006",
"0.61332375",
"0.61093324",
"0.6102551",
"0.61013913",
"0.6096... | 0.0 | -1 |
GET /locations GET /locations.json | def search
@search = Location.near(params[:search], 15, :order => :distance)
@query = params[:search]
@locations = @search
@filtros = ajustaFiltros
@precios = precios(@locations)
@campos = self.campos
@places = places(@locations,@filtros)
@facets = facetas(@locations, @filtros)
@json = @locations.to_gmaps4rails
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def locations\n get('locations')\n end",
"def get_location\n as_json(get_results('/locations.json'))\n end",
"def index\n locations = Location.all\n render json: locations\n end",
"def index\n locations = @project.locations.all\n render json: { locations: locations }\n end",
"def inde... | [
"0.8453372",
"0.8234143",
"0.7760002",
"0.75519973",
"0.740187",
"0.7388884",
"0.7377007",
"0.7368393",
"0.736024",
"0.7325595",
"0.72686946",
"0.72633356",
"0.7240139",
"0.7225058",
"0.7208155",
"0.7189576",
"0.7168539",
"0.71605265",
"0.712463",
"0.7104432",
"0.7091841",
... | 0.0 | -1 |
GET /locations/new GET /locations/new.json | def new
@location = Location.new
@json = @location.to_gmaps4rails
respond_to do |format|
format.html # new.html.erb
format.json { render json: @location }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n @location = Location.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @location }\n end\n end",
"def new\n @location = Location.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @location ... | [
"0.78486854",
"0.78486854",
"0.78486854",
"0.78486854",
"0.78486854",
"0.77727544",
"0.776663",
"0.776663",
"0.77340513",
"0.76910096",
"0.7683446",
"0.7670686",
"0.7583331",
"0.75309056",
"0.74684495",
"0.7386545",
"0.73852605",
"0.73413974",
"0.7314568",
"0.7268835",
"0.726... | 0.7158845 | 24 |
POST /locations POST /locations.json | def create
@location = Location.new(params[:location].merge!(:user => current_user))
respond_to do |format|
if @location.save
format.html { redirect_to @location, notice: 'La habitación se ha guardado exitosamente.' }
format.json { render json: @location, status: :created, location: @location }
else
format.html { render action: "new" }
format.json { render json: @location.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @location = Location.new(location_params)\n\n if @location.save \n render :json => { status: :created, location: @location }\n else\n render :json => { errors: @location.errors, status: :unprocessable_entity }\n end\n end",
"def create\r\n @location = L... | [
"0.70938414",
"0.70937365",
"0.6989754",
"0.68999434",
"0.6885416",
"0.68796176",
"0.68285424",
"0.6803978",
"0.67866087",
"0.6779879",
"0.6770149",
"0.6770149",
"0.6770149",
"0.6770149",
"0.6769066",
"0.6761569",
"0.67089725",
"0.6707837",
"0.66919154",
"0.6659068",
"0.66590... | 0.64675057 | 36 |
PUT /locations/1 PUT /locations/1.json | def update
@location = Location.find(params[:id])
respond_to do |format|
if @location.update_attributes(params[:location])
format.html { redirect_to @location, notice: 'La habitación se ha guardado exitosamente.' }
format.json { head :no_content }
else
format.html { render action: "edit" }
format.json { render json: @location.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n render json: Location.update(params[\"id\"], params[\"location\"])\n end",
"def update_location(params)\n @client.put(\"#{path}/location\", nil, params, \"Content-Type\" => \"application/json\")\n end",
"def update\r\n @location = Location.find(params[:id])\r\n \r\n respond_to do ... | [
"0.7454527",
"0.734054",
"0.69825995",
"0.67722267",
"0.6600625",
"0.6579759",
"0.6552991",
"0.65368855",
"0.65152794",
"0.64990866",
"0.64946395",
"0.6490946",
"0.6472603",
"0.6460661",
"0.64511895",
"0.6427815",
"0.6396173",
"0.6396173",
"0.6396173",
"0.6396173",
"0.6395882... | 0.61976796 | 41 |
DELETE /locations/1 DELETE /locations/1.json | def destroy
@location = Location.find(params[:id])
@location.destroy
respond_to do |format|
format.html { redirect_to locations_url }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete\n render json: Location.delete(params[\"id\"])\n end",
"def destroy\r\n @location = Location.find(params[:id])\r\n @location.destroy\r\n\r\n respond_to do |format|\r\n format.json { head :no_content }\r\n end\r\n end",
"def destroy\n @location = Location.find(params[:id])\n ... | [
"0.7645932",
"0.7416999",
"0.7319656",
"0.73018676",
"0.7292965",
"0.7292965",
"0.72866315",
"0.7276926",
"0.7261458",
"0.72602606",
"0.72602606",
"0.72602606",
"0.72602606",
"0.72483915",
"0.7226834",
"0.72016335",
"0.7184247",
"0.7173217",
"0.71658397",
"0.7111943",
"0.7105... | 0.728289 | 14 |
Read the file one byte at a time | def read_body(&block)
while byte = @body.read(1)
yield byte
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read()\n @file.seek(@address)\n @file.getc\n end",
"def read(bytes)\n read_file(@reader, bytes) unless peek_named_pipe(@reader).zero?\n end",
"def each\n File.open(to_path, 'rb') do |file|\n while chunk = file.read(16384)\n yield chunk\n... | [
"0.68593466",
"0.6827926",
"0.6766371",
"0.66183096",
"0.66139156",
"0.65848696",
"0.6485944",
"0.64555776",
"0.64555776",
"0.64334774",
"0.64253825",
"0.63871706",
"0.6354275",
"0.63232845",
"0.6267984",
"0.62639207",
"0.62639207",
"0.6231327",
"0.6207792",
"0.62033266",
"0.... | 0.0 | -1 |
POST /kpi_types POST /kpi_types.json | def create
@kpi_type = KpiType.new(kpi_type_params)
if @kpi_type.save
flash[:success] = 'KPI Type was successfully created.'
redirect_to :back
else
flash[:danger] = 'KPI Type was not created.'
redirect_to :back
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kpi_type_params\n params.require(:kpi_type).permit(:name,:code)\n end",
"def type_params\n params.from_jsonapi.require(:type).permit(:name)\n end",
"def add_dummy_type\n params[:data] ||= {}\n params[:data][:type] = resource_klass._type.to_s\n end",
"def create_types\n\t\t[]\n\tend",
... | [
"0.67659",
"0.6282521",
"0.6281636",
"0.6183373",
"0.6183373",
"0.6123466",
"0.6123466",
"0.60953045",
"0.6090268",
"0.598207",
"0.5931976",
"0.5849073",
"0.5815785",
"0.5815785",
"0.5742959",
"0.5721692",
"0.57141656",
"0.5691886",
"0.5669951",
"0.5633514",
"0.56115025",
"... | 0.6586921 | 1 |
PATCH/PUT /kpi_types/1 PATCH/PUT /kpi_types/1.json | def update
if @kpi_type.update(kpi_type_params)
flash[:success] = 'KPI Type was successfully updated.'
redirect_to :back
else
flash[:danger] = 'KPI Type was not updated.'
redirect_to :back
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_type\n\t\t\trender json: User.update_type_by_id(params[:id], params[:type], params[:is])\n\t\tend",
"def update\n @type.update(type_params)\n end",
"def patch(type, info)\n path, info = type_info(type, :path), force_case(info)\n ida = type == :client ? 'client_id' : 'id'\n raise Argumen... | [
"0.64834076",
"0.63348955",
"0.6264754",
"0.61594623",
"0.6146158",
"0.6144301",
"0.6132821",
"0.6126535",
"0.6126196",
"0.61250424",
"0.61238486",
"0.61134434",
"0.6110178",
"0.60877174",
"0.6074158",
"0.60712737",
"0.60435665",
"0.6040991",
"0.60351515",
"0.6022848",
"0.600... | 0.6594203 | 0 |
DELETE /kpi_types/1 DELETE /kpi_types/1.json | def destroy
@kpi_type.destroy
flash[:success] = 'KPI Type was successfully deleted.'
redirect_to :back
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @type = Type.find(params[:id])\n @type.destroy\n\n respond_to do |format|\n format.html { redirect_to types_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @itype = Itype.find(params[:id])\n @itype.destroy\n\n respond_to do |format|\n forma... | [
"0.6899133",
"0.68929327",
"0.6790414",
"0.677679",
"0.676806",
"0.6766484",
"0.6763869",
"0.6734256",
"0.6725124",
"0.6722001",
"0.67125696",
"0.67114246",
"0.67042875",
"0.6697558",
"0.6692546",
"0.6691969",
"0.66915977",
"0.6684318",
"0.6658651",
"0.66412884",
"0.66391337"... | 0.6970028 | 0 |
Use callbacks to share common setup or constraints between actions. | def js_request?
request.format.js?
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.