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 |
|---|---|---|---|---|---|---|
discover the address for this trip place from its relationships | def address
return poi.address unless poi.nil?
return place.address unless place.nil?
addr = get_address
return addr.blank? ? raw_address : addr
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addresses\n query(:address)\n end",
"def residential_address\n return unless @user.loa3?\n\n dig_out('addresses', 'address_pou', VAProfile::Models::Address::RESIDENCE)\n end",
"def address_by_place_id(place_id)\n where(:place_id => place_id).first\n end",
"def get_add... | [
"0.6656821",
"0.65080637",
"0.6384102",
"0.63673544",
"0.63088083",
"0.63019145",
"0.6223912",
"0.62215227",
"0.6199937",
"0.61691785",
"0.61642265",
"0.61551803",
"0.6148008",
"0.6113723",
"0.61110044",
"0.61011106",
"0.6071704",
"0.6055317",
"0.6050442",
"0.60323864",
"0.60... | 0.6271624 | 6 |
discover the default string value for this trip place from its relationships | def to_s
return poi.to_s unless poi.nil?
return place.to_s unless place.nil?
addr = get_address
return addr.blank? ? raw_address : addr
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preferred_name(default, preferred)\n if default.nil? && preferred.nil?\n 'No one'\n elsif preferred.nil?\n default\n else\n preferred\n end\n end",
"def default_value\n default_db_value ? default_db_value.to_s : \"null\"\n end",
"def get_defau... | [
"0.56976575",
"0.5662383",
"0.56051373",
"0.5583346",
"0.55768996",
"0.5563286",
"0.55539644",
"0.5551917",
"0.5550344",
"0.55154765",
"0.5515414",
"0.5507771",
"0.5482009",
"0.5435568",
"0.5431843",
"0.5430972",
"0.5425953",
"0.5424553",
"0.53832686",
"0.53058046",
"0.526963... | 0.0 | -1 |
discover the zipcode for this trip place from its relationships | def zipcode
return poi.zip unless poi.nil?
return place.zip unless place.nil?
return get_zipcode
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def postal_code\n self[:zip]\n end",
"def zip\n self[:address][:postalCode]\n end",
"def search_zip_code\r\n @addresses = Address.find_by_zip_code(params[:address][:zip_code])\r\n end",
"def load_districts_zip(zip_code)\n params = {'zip' => zip_code}\n @districts = process('... | [
"0.63452387",
"0.63422775",
"0.6255217",
"0.6154878",
"0.6084261",
"0.59584016",
"0.5884672",
"0.5824158",
"0.57361025",
"0.5713872",
"0.570411",
"0.5701743",
"0.5671898",
"0.5671898",
"0.56452024",
"0.5644597",
"0.5627292",
"0.56267315",
"0.5623451",
"0.56075126",
"0.5591091... | 0.6343369 | 1 |
METHOD TO CREATE A LIST input: string of items separated by spaces (example: "carrots apples cereal pizza") steps: | def create_list(title, list_arr)
# grocery_list will be a string from user
# assign an empty hash (will eventually be the list)
final_list = {}
# use split method to get list items
list_arr = list_arr.split
# Iterate through the elements of the array and insert to hash
# set default quantity
list_arr.ea... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_list (item_list)\n #convert user input to array\n item_list = item_list.split(' ')\n return item_list\nend",
"def new_list(item_String, quantity = 1)\n $list = []\n array_strings = item_String.split\n array_strings.each do |element|\n \tlist_item = {\n \t\tquantity: quantity,\n \t\titem: elemen... | [
"0.7490359",
"0.72430724",
"0.71403927",
"0.70354414",
"0.6922523",
"0.6903794",
"0.6864969",
"0.68273455",
"0.68128616",
"0.67992324",
"0.6781416",
"0.6766408",
"0.6749295",
"0.6735803",
"0.67265195",
"0.67030793",
"0.66947573",
"0.66856885",
"0.66623735",
"0.6659941",
"0.66... | 0.0 | -1 |
output: [hash] METHOD TO ADD AN ITEM TO A LIST input: list, item name, and optional quantity | def add_item(list, add_item, add_quantity=1)
# steps:
# Add item as key and quantity as value to final_list hash(item and quantity will be user inputs)
list[add_item] = add_quantity
# Return updated hash
list
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_item(list, item_name, quantity)\n\tlist[item_name] = quantity\n\tlist\nend",
"def add_item(list, item_name, quantity)\n\tlist[item_name] = quantity\n\tlist\nend",
"def add(list, item_name, quantity)\n\tlist[item_name] = quantity\n\tlist\nend",
"def add_item(list, item_name, quantity = 1)\n\tlist[item... | [
"0.8829534",
"0.8829534",
"0.88240135",
"0.87028354",
"0.87025785",
"0.87025785",
"0.86511934",
"0.86244744",
"0.85747325",
"0.85730284",
"0.85553586",
"0.85238117",
"0.85012025",
"0.84922564",
"0.8489195",
"0.84753567",
"0.84693295",
"0.84591496",
"0.84468234",
"0.8444895",
... | 0.838218 | 29 |
output: updated hash METHOD TO REMOVE AN ITEM FROM THE LIST input: list and item name | def remove_item(list, rm_item)
# steps:
# use delete method with key (item) as argument
list.delete(rm_item)
# return list
list
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_item(list_name, item)\r\n# input: list, item name\r\n# steps: delete item name and value from hash\r\n list_name.delete(item)\r\n# output: updated hash with item removed\r\np list_name\r\nend",
"def list_remove(hash_items, item_name)\n hash_items.delete(item_name)\n return hash_items\nend",
"def ... | [
"0.8797937",
"0.8641972",
"0.85495484",
"0.8446512",
"0.83836013",
"0.8378233",
"0.8357819",
"0.8357819",
"0.8357819",
"0.83380544",
"0.8315129",
"0.83071345",
"0.8303172",
"0.83007216",
"0.82781786",
"0.8249939",
"0.8248783",
"0.82440776",
"0.8182585",
"0.8151725",
"0.812812... | 0.7696101 | 86 |
output: updated hash METHOD TO UPDATE THE QUANTITY OF AN ITEM input: list, item name, new quantity | def update_quantity(list, upd_item, new_quantity)
# steps:
# reassign key (item) a new value (quantity)
list[upd_item] = new_quantity
# return list
list
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_quantity(list_name, item, value)\r\n# input: list, item name, new quantity\r\n# steps: find item in the hash and change quantity to new quantity\r\n list_name[item] = value\r\n# output: updated hash with new value for item key\r\n p list_name\r\nend",
"def update_qty(list_hash, item, qty)\r\n \tlis... | [
"0.87030816",
"0.85322976",
"0.8530851",
"0.85046077",
"0.8499819",
"0.8499819",
"0.84602684",
"0.8432709",
"0.8424952",
"0.83793443",
"0.8347535",
"0.8347497",
"0.8328248",
"0.8325422",
"0.83117807",
"0.8292133",
"0.82835966",
"0.82835966",
"0.82717055",
"0.8263529",
"0.8253... | 0.8143599 | 31 |
output: updated hash METHOD TO PRINT A LIST AND MAKE IT LOOK PRETTY input: title, list | def print_list(title,list)
# steps:
# print title of list (will ask user for this input)
puts "**********************"
puts " #{title.upcase}:"
puts "**********************"
# print headers of item and quantity
puts " # ITEM"
puts "----------------------"
# print each item and it's quantity, bulle... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_to_print(title,list)\n line = \"\" \n 1.upto(title.size){line << \"-\"}\n title = title + \"\\n\" + line + \"\\n\"\n return title + (list.collect {|x| \" => #{x}\" }).join(\"\\n\")\n end",
"def print_list(list_name)\r\n# input: hash name\r\n# steps: add dashes and spacing\r\np \"List:\"\r\n... | [
"0.77988094",
"0.7737018",
"0.75002086",
"0.7404148",
"0.73617095",
"0.7340666",
"0.7319176",
"0.7298175",
"0.72817343",
"0.71640044",
"0.7163696",
"0.7107956",
"0.710603",
"0.71029",
"0.7101576",
"0.7101576",
"0.7088003",
"0.70704913",
"0.704006",
"0.70399714",
"0.70278066",... | 0.7729893 | 2 |
def name replaced with attr_reader or attr_accessor | def lost? # ruby style/convention says methods that return booleans should end w/ "?", so can't just use attr_reader/attr_writer/attr_accessor
@lost
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def attr_accessor(name)\n attr_reader(name)\n attr_writer(name)\n nil\n end",
"def attr_reader(sym, *more) end",
"def attr_reader(*)\n end",
"def define_attr_reader(name)\n define_method(name) do\n instance_variable_get(\"@#{name}\")\n end\n end",
"def attr(name); end... | [
"0.75800496",
"0.75754565",
"0.75579435",
"0.7492696",
"0.72385854",
"0.7208101",
"0.7197241",
"0.71849245",
"0.70393854",
"0.7014108",
"0.6943722",
"0.69365406",
"0.69219846",
"0.69157404",
"0.6898428",
"0.68894714",
"0.68676114",
"0.68610567",
"0.685036",
"0.68164617",
"0.6... | 0.0 | -1 |
Return urlsafe base64 HMAC for data, assumes hmac_secret is set. | def compute_hmac(data)
s = [compute_raw_hmac(data)].pack('m').chomp!("=\n")
s.tr!('+/', '-_')
s
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_hmac_hash(secret, data)\n algo = 'SHA1'\n _digest = OpenSSL::Digest.new(algo)\n OpenSSL::HMAC.hexdigest(_digest, secret, data)\n end",
"def hmac_signature(key, data)\n sha = HMAC::SHA1.new(key)\n sha.update(data)\n base64(sha.digest)\n end",
"def signature_for(data, secret)\... | [
"0.71493673",
"0.7005676",
"0.670317",
"0.66372913",
"0.66372913",
"0.66000056",
"0.6567909",
"0.6560621",
"0.65314186",
"0.6423527",
"0.6398781",
"0.62952703",
"0.62781453",
"0.6062815",
"0.6042645",
"0.5962813",
"0.5905947",
"0.58647203",
"0.5829988",
"0.5819255",
"0.581065... | 0.7223387 | 0 |
If the account_password_hash_column is set, the password hash is verified in ruby, it will not use a database function to do so, it will check the password hash using bcrypt. | def account_password_hash_column
nil
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_password(password, hash)\n BCrypt::Password.new(hash) == password\n end",
"def get_password_hash\n if account_password_hash_column\n account![account_password_hash_column]\n elsif use_database_authentication_functions?\n db.get(Sequel.function(function_name(:rodauth_get_salt... | [
"0.7374337",
"0.7356962",
"0.7332111",
"0.708981",
"0.7004459",
"0.6978496",
"0.69761056",
"0.69653875",
"0.68635774",
"0.6860733",
"0.6835812",
"0.6835148",
"0.6820272",
"0.67767113",
"0.67736965",
"0.67410606",
"0.6701725",
"0.66954476",
"0.66886747",
"0.66748405",
"0.66654... | 0.7018097 | 4 |
Return a string for the parameter name. This will be an empty string if the parameter doesn't exist. | def param(key)
param_or_nil(key).to_s
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def param_name\n @param_name.respond_to?(:call) ? @param_name.call : @param_name\n end",
"def param_namer(param)\n \"$_#{param}\"\n end",
"def parameter_string\n\t\tend",
"def parameter_string\n \"\"\n end",
"def param_name(key)\n first, *rest = keys(key)\n if firs... | [
"0.7811591",
"0.7329533",
"0.69914734",
"0.6978847",
"0.68234736",
"0.68229944",
"0.68144816",
"0.67942953",
"0.67942953",
"0.67942953",
"0.6788499",
"0.6788499",
"0.67531747",
"0.6744404",
"0.6744404",
"0.6744404",
"0.6744404",
"0.6744404",
"0.6744404",
"0.6698332",
"0.66686... | 0.75049573 | 1 |
Return a string for the parameter name, or nil if there is no parameter with that name. | def param_or_nil(key)
value = raw_param(key)
unless value.nil?
value = value.to_s
value = over_max_bytesize_param_value(key, value) if max_param_bytesize && value.bytesize > max_param_bytesize
value = null_byte_parameter_value(key, value) if value && value.include?("\0")
end
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def param_name\n @param_name.respond_to?(:call) ? @param_name.call : @param_name\n end",
"def param(key)\n param_or_nil(key).to_s\n end",
"def parameter(name)\n parameters.find { |p| p.name == name.to_s }\n end",
"def param_for_name(name)\n @params.fetch(name, n... | [
"0.7839522",
"0.75286406",
"0.7044579",
"0.69348574",
"0.68219143",
"0.6806134",
"0.6791785",
"0.6788562",
"0.6786684",
"0.67695135",
"0.67206293",
"0.6650375",
"0.66407067",
"0.66407067",
"0.6639024",
"0.6635799",
"0.663501",
"0.663501",
"0.663501",
"0.6616055",
"0.65998703"... | 0.6221218 | 68 |
Return nil by default for values over maximum bytesize. | def over_max_bytesize_param_value(key, value)
nil
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_allowed_bytesize(v, max)\n end",
"def default_max_size; end",
"def max_size\n 1\n end",
"def default_max_in_memory_size\n @default_max_in_memory_size || DEFAULT_MAX_IN_MEMORY_SIZE\n end",
"def max_size; end",
"def max_size=(_arg0); end",
"def specific_max_size(number); ... | [
"0.7048917",
"0.69685555",
"0.6604613",
"0.65568906",
"0.65325785",
"0.64720196",
"0.6436458",
"0.6316911",
"0.63024276",
"0.6302215",
"0.62844723",
"0.6233355",
"0.6225882",
"0.62036234",
"0.6199145",
"0.6152728",
"0.6145607",
"0.61380404",
"0.6134343",
"0.60376334",
"0.6033... | 0.74810094 | 0 |
Return nil by default for values with null bytes | def null_byte_parameter_value(key, value)
nil
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_null_byte(v)\n end",
"def null \n return @raw.null \n end",
"def process_nillable_values(args:)\n args[:byte_size] = nil if args[:byte_size].blank?\n args\n end",
"def process_nillable_values(args:)\n args[:byte_size] = nil unless args[:byte_size].present?\n args\n ... | [
"0.7342216",
"0.68070954",
"0.66826034",
"0.656124",
"0.64034367",
"0.6388334",
"0.6386083",
"0.63598377",
"0.6342451",
"0.6321569",
"0.6313501",
"0.6313254",
"0.6161936",
"0.6160538",
"0.61589456",
"0.61338544",
"0.61203986",
"0.6091144",
"0.6043458",
"0.6041877",
"0.6041877... | 0.73827493 | 0 |
Don't set an error status when redirecting in an error case, as a redirect status is needed. | def set_redirect_error_status(status)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def redirect(location, status = '302'); request.redirect(location, status); end",
"def redirect?\n # redirects are 3xx\n return @status >= 300 && @status < 400\n end",
"def redirect_ok; end",
"def redirect_ok; end",
"def redirect?; end",
"def redirect?\n 300 <= code && code < 400\n end... | [
"0.72776395",
"0.7213422",
"0.7120492",
"0.7120492",
"0.70450735",
"0.6884401",
"0.6833134",
"0.6813714",
"0.6789967",
"0.67788184",
"0.6737465",
"0.6719334",
"0.67080665",
"0.67079306",
"0.67056316",
"0.67028445",
"0.669154",
"0.6683165",
"0.6648155",
"0.6641535",
"0.6635181... | 0.8550512 | 0 |
Get the password hash for the user. When using database authentication functions, note that only the salt is returned. | def get_password_hash
if account_password_hash_column
account![account_password_hash_column]
elsif use_database_authentication_functions?
db.get(Sequel.function(function_name(:rodauth_get_salt), account ? account_id : session_value))
else
# :nocov:
password_hash_ds.get(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hash_user_password\n self.password = sha1_digest(self.user_password, self.salt)\n self.user_password = nil\n end",
"def hash_password\n if password.present?\n self.salt = BCrypt::Engine.generate_salt\n self.hashed_password = BCrypt::Engine.hash_secret(password, self.salt)\n end\n end"... | [
"0.73407525",
"0.7305118",
"0.7273412",
"0.72535986",
"0.701587",
"0.6994785",
"0.68946946",
"0.68771034",
"0.6866493",
"0.68236434",
"0.68070513",
"0.67818266",
"0.67270565",
"0.67245585",
"0.66816676",
"0.66433036",
"0.6640192",
"0.6633492",
"0.6633174",
"0.66188866",
"0.66... | 0.80357903 | 0 |
This is needed for jdbc/sqlite, which returns timestamp columns as strings | def convert_timestamp(timestamp)
timestamp = db.to_application_timestamp(timestamp) if timestamp.is_a?(String)
timestamp
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_sql\n \"timestamp '#{to_s}'\"\n end",
"def timestamp(row)\n row[0].to_f\nend",
"def to_sql\n self.strftime(\"%Y-%m-%d %H:%M:%S\")\n \tend",
"def type_literal_generic_datetime(column)\n :timestamp\n end",
"def timestamp\n self.created_at.to_s(:db)\n end",
"def to_sql\n ... | [
"0.7502201",
"0.72052735",
"0.69924843",
"0.69723177",
"0.6725154",
"0.6671377",
"0.64212924",
"0.63930243",
"0.6342454",
"0.63148004",
"0.62781566",
"0.62503713",
"0.6234043",
"0.62166214",
"0.6190682",
"0.61698246",
"0.6159796",
"0.6158178",
"0.61475915",
"0.6126058",
"0.61... | 0.6015667 | 33 |
This is used to avoid race conditions when using the pattern of inserting when an update affects no rows. In such cases, if a row is inserted between the update and the insert, the insert will fail with a uniqueness error, but retrying will work. It is possible for it to fail again, but only if the row is deleted befor... | def retry_on_uniqueness_violation(&block)
if raises_uniqueness_violation?(&block)
yield
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sneaky_save(avoid_insert_conflict: nil)\n begin\n sneaky_create_or_update(avoid_insert_conflict: avoid_insert_conflict)\n rescue ActiveRecord::StatementInvalid\n false\n end\n end",
"def raises_uniqueness_violation?(&block)\n transaction(:savepoint=>:only, &block)\n false\n r... | [
"0.67513746",
"0.65868825",
"0.6517185",
"0.63281465",
"0.62889713",
"0.6247235",
"0.61678493",
"0.61678493",
"0.6159286",
"0.6152866",
"0.59580976",
"0.5857649",
"0.5827829",
"0.57634676",
"0.57280236",
"0.5725281",
"0.572263",
"0.56740296",
"0.5632502",
"0.56265414",
"0.562... | 0.620919 | 6 |
In cases where retrying on uniqueness violations cannot work, this will detect whether a uniqueness violation is raised by the block and return the exception if so. This method should be used if you don't care about the exception itself. | def raises_uniqueness_violation?(&block)
transaction(:savepoint=>:only, &block)
false
rescue unique_constraint_violation_class => e
e
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def retry_on_uniqueness_violation(&block)\n if raises_uniqueness_violation?(&block)\n yield\n end\n end",
"def retry_transaction(&block)\n tries = 3\n begin\n yield\n rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique\n tries -= 1\n if tries > 0\n ... | [
"0.8227882",
"0.62486017",
"0.5877959",
"0.5869566",
"0.5543474",
"0.5516552",
"0.5399367",
"0.5380863",
"0.5317911",
"0.5317804",
"0.5317804",
"0.53080606",
"0.53064775",
"0.53021216",
"0.5301212",
"0.52759105",
"0.5213642",
"0.51614475",
"0.51512957",
"0.50801015",
"0.50596... | 0.7240546 | 1 |
Work around jdbc/sqlite issue where it only raises ConstraintViolation and not UniqueConstraintViolation. | def unique_constraint_violation_class
if db.adapter_scheme == :jdbc && db.database_type == :sqlite
# :nocov:
Sequel::ConstraintViolation
# :nocov:
else
Sequel::UniqueConstraintViolation
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_detecting_duplicate_entry_constraint_violation\n begin\n save\n rescue ActiveRecord::StatementInvalid => e\n # Would that rails gave us the nested exception to check...\n if e.message =~ /.*[Dd]uplicate/\n errors.add_to_base(translate_with_theme('duplicate_entry_please_try_agai... | [
"0.71445197",
"0.66329813",
"0.6396467",
"0.628304",
"0.622174",
"0.6119858",
"0.6055775",
"0.60428435",
"0.60182035",
"0.60038817",
"0.592732",
"0.5918079",
"0.58941764",
"0.5809525",
"0.57830614",
"0.57510746",
"0.57140636",
"0.56878424",
"0.56799215",
"0.56777626",
"0.5648... | 0.70253205 | 1 |
This is needed on MySQL, which doesn't support non constant defaults other than CURRENT_TIMESTAMP. | def set_deadline_value(hash, column, interval)
if set_deadline_values?
# :nocov:
hash[column] = Sequel.date_add(Sequel::CURRENT_TIMESTAMP, interval)
# :nocov:
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def default_values\n self.date ||= DateTime.now\n end",
"def default_timestamp_format\n \"TIMESTAMP '%Y-%m-%d %H:%M:%S%N %z'\".freeze\n end",
"def generate_default_values\n self.created_at = DateTime.now unless self.created_at\n end",
"def timestamps\n opts = @table.schem... | [
"0.6554644",
"0.65061677",
"0.6424828",
"0.6330221",
"0.62712324",
"0.6250039",
"0.6170995",
"0.60692316",
"0.60148466",
"0.60006034",
"0.5992138",
"0.5974885",
"0.5951453",
"0.58762014",
"0.5859642",
"0.5848238",
"0.5836488",
"0.5833915",
"0.58169585",
"0.57981086",
"0.57744... | 0.0 | -1 |
Set the template path only if there isn't an overridden template in the application. Result should replace existing template opts. | def _template_opts(opts, page)
opts = scope.send(:find_template, scope.send(:parse_template_opts, page, opts))
unless File.file?(scope.send(:template_path, opts))
opts[:path] = template_path(page)
end
opts
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def template_path\n @default_options.fetch(:template_path, nil)\n end",
"def template_path(template, opts)\n t = template.to_s\n if (v = @_view_subdir) && t !~ /\\//\n template = \"#{v}/#{t}\"\n end\n super\n end",
"def assign_template\n @templ... | [
"0.73226917",
"0.724883",
"0.6801521",
"0.67943865",
"0.67519003",
"0.6743041",
"0.6658982",
"0.6565212",
"0.6557703",
"0.6551305",
"0.6433538",
"0.63292116",
"0.63167316",
"0.6244802",
"0.62268543",
"0.61312705",
"0.61067533",
"0.6104239",
"0.60850424",
"0.6061657",
"0.60356... | 0.6580649 | 7 |
optional filters for defining usage according to Casein::AdminUser access_levels before_filter :needs_admin, :except => [:action1, :action2] before_filter :needs_admin_or_current_user, :only => [:action1, :action2] | def index
@casein_page_title = 'Categorias'
@categories = Category.order(sort_order(:nombre)).paginate :page => params[:page]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def authorize_admin\n redirect_to :login unless current_user.permission.manage_app ||\n current_user.permission.manage_attrs ||\n current_user.permission.manage_achievement_categories ||\n current_user.permission.manage_talent_trees ||\n current_user.permission.manage_talents ||\n curre... | [
"0.7267958",
"0.6981016",
"0.69264644",
"0.6716236",
"0.6716236",
"0.6716236",
"0.67104375",
"0.66513115",
"0.6617181",
"0.65406954",
"0.6537394",
"0.651807",
"0.6457908",
"0.64508194",
"0.64484423",
"0.64442724",
"0.6438858",
"0.64349455",
"0.6384369",
"0.63587534",
"0.63312... | 0.0 | -1 |
write your code here | def greet (name)
"Hello, #{name}!"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def code; end",
"def code; end",
"def code; end",
"def code; end",
"def code; end",
"def code; end",
"def code; end",
"def custom; end",
"def custom; end",
"def run\n end",
"def method\n\t\t# code code\n\tend",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; ... | [
"0.7043092",
"0.7043092",
"0.7043092",
"0.7043092",
"0.7043092",
"0.7043092",
"0.7043092",
"0.6382698",
"0.6382698",
"0.6352213",
"0.6334336",
"0.63308704",
"0.63308704",
"0.63308704",
"0.63308704",
"0.63308704",
"0.63308704",
"0.63308704",
"0.63308704",
"0.63308704",
"0.6319... | 0.0 | -1 |
TODO: select with name[] | def select_multi(field_name, choices, options = {})
power_options = power_options!(field_name, options)
# generic_field(:select, super(field_name, choices, options), field_name, power_options)
generic_field(:select, 'SELECT MULTI', field_name, power_options)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select(*names)\n result = []\n names.each { |name|\n name = Field.name_canonicalize(name)\n result.concat(find_all { |n, v|\n n.downcase == name\n })\n }\n result\n end",
"def fields_by_name(name)\n @fields.select{|f|f.name==... | [
"0.68360335",
"0.6645509",
"0.6546593",
"0.62704164",
"0.6232201",
"0.61981314",
"0.61889815",
"0.61889815",
"0.618224",
"0.61465955",
"0.61464155",
"0.6135498",
"0.60959154",
"0.60161924",
"0.60161924",
"0.6005286",
"0.60037434",
"0.59386057",
"0.5924485",
"0.5924485",
"0.59... | 0.0 | -1 |
First line starts from middle of all the columns. In next line, expand left side and right side with '' in index range(middle_idx line_index, middle_idx + line_index) params: xi line_index of 0 based. return: an array of column index numbers corresponding to the current line index which can make the tree shape. | def algorithm(xi)
yi_min = self.height - 1 - xi
yi_max = self.height - 1 + xi
y_array = (yi_min..yi_max).to_a
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tree_at(line, column); end",
"def left_child(indx)\n 2*indx + 1\n end",
"def horizontal_grid_line(index)\n if @handle.ptr == nil\n raise \"this is disposed\"\n end\n result = Native.GraphComponentState_horizontal_grid_line(@handle.ptr, index)\n ... | [
"0.6695516",
"0.5569071",
"0.54340374",
"0.54031396",
"0.54011583",
"0.5348261",
"0.53228736",
"0.52889764",
"0.5281722",
"0.5252969",
"0.51921785",
"0.51887536",
"0.5144769",
"0.5127972",
"0.50927836",
"0.5063194",
"0.5059906",
"0.5057241",
"0.5037174",
"0.50164026",
"0.5008... | 0.0 | -1 |
POST /frontapp_support_sources POST /frontapp_support_sources.json | def create
@support_source = FrontappSupportSource.new(frontapp_support_source_params)
respond_to do |format|
if @support_source.save
format.html { redirect_to support_sources_path,
notice: 'Support source was successfully created.' }
format.json { render :show, status: :created... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def frontapp_support_source_params\n params.require(:frontapp_support_source).\n permit(:name, :frontapp_auth_token,\n :frontapp_user_id, :frontapp_inbox_ids_as_string).\n merge(user: current_user)\n end",
"def set_frontapp_support_source\n @support_source = current_user.frontapp_support_... | [
"0.6840675",
"0.6512786",
"0.6216179",
"0.6091219",
"0.57109064",
"0.55643976",
"0.5503779",
"0.5502661",
"0.5502556",
"0.5485731",
"0.5462232",
"0.5425297",
"0.534418",
"0.5332665",
"0.53206515",
"0.5293588",
"0.52738035",
"0.52652967",
"0.5262682",
"0.52316916",
"0.52239853... | 0.7467037 | 0 |
PATCH/PUT /frontapp_support_sources/1 PATCH/PUT /frontapp_support_sources/1.json | def update
respond_to do |format|
if @support_source.update(frontapp_support_source_params)
format.html { redirect_to @support_source,
notice: 'Support source was successfully updated.' }
format.json { render :show, status: :ok, location: @support_source }
else
format.h... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n sources = Fenix::Store::Converter::Flattener.sources params[:sources]\n respond_to do |format|\n if @host.set_sources sources\n format.html { redirect_to source, notice: 'SourceList was successfully updated.' }\n format.json { render :show, status: :ok, location: source }\n ... | [
"0.6636469",
"0.64439833",
"0.6161364",
"0.6118049",
"0.60415477",
"0.6025269",
"0.59855866",
"0.5952451",
"0.5941746",
"0.5926055",
"0.59219974",
"0.5919296",
"0.5867781",
"0.5836152",
"0.5822313",
"0.58192176",
"0.5817657",
"0.58020675",
"0.57862246",
"0.5770091",
"0.576766... | 0.73294055 | 0 |
DELETE /frontapp_support_sources/1 DELETE /frontapp_support_sources/1.json | def destroy
@support_source.destroy
respond_to do |format|
format.html { redirect_to support_sources_url,
notice: 'Support source was successfully destroyed.' }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n authorize_user!\n respond_to do |format|\n format.html { redirect_to sources_path(@source) }\n format.json { head :no_content }\n @source.destroy\n end\n end",
"def destroy\n @cla_source.destroy\n respond_to do |format|\n format.html { redirect_to cla_sources_url... | [
"0.69014657",
"0.68325377",
"0.677435",
"0.67720145",
"0.67617685",
"0.67617685",
"0.67615503",
"0.67182916",
"0.66766065",
"0.6612491",
"0.65844524",
"0.6569961",
"0.65570587",
"0.65509456",
"0.65509456",
"0.6533156",
"0.6501823",
"0.6498255",
"0.64895874",
"0.6483071",
"0.6... | 0.7042307 | 0 |
Use callbacks to share common setup or constraints between actions. | def set_frontapp_support_source
@support_source = current_user.frontapp_support_sources.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_... | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576"... | 0.0 | -1 |
Never trust parameters from the scary internet, only allow the white list through. | def frontapp_support_source_params
params.require(:frontapp_support_source).
permit(:name, :frontapp_auth_token,
:frontapp_user_id, :frontapp_inbox_ids_as_string).
merge(user: current_user)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n... | [
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",... | 0.0 | -1 |
Relies on ActiveRecord == | def test_sort
[ FactoryGirl.build(:category, :id => 2), FactoryGirl.build(:category, :id => 1), FactoryGirl.build(:category)].sort
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ==\n end",
"def ==(other); false; end",
"def ==(other); end",
"def ==(other); end",
"def ==(other); end",
"def ==(other); end",
"def ==(other); end",
"def ==(other); end",
"def ==(other); end",
"def ==(other); end",
"def ==(other); end",
"def ==(other); end",
"def ==(other); end",
... | [
"0.774361",
"0.77093244",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
"0.76522046",
... | 0.0 | -1 |
orders scores ind descending value, on score board | def create
score = current_user.scores.new(score_params)
if score.save
render json: score
else
render json: { errors: score.errors.join(',') }, status: 422
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sort_using_rank\n score[1]\n end",
"def sort_scores(unsorted_scores, highest_possible_score)\n arr = []\n unsorted_scores.each do |score|\n if arr[score]\n arr[score] += 1\n else\n arr[score] = 1\n end\n end\n \n output = []\n arr.each_with_index do |num, idx|\n if num\n n... | [
"0.7259435",
"0.7149945",
"0.68166596",
"0.67952",
"0.67807746",
"0.67765516",
"0.66983306",
"0.665392",
"0.6619831",
"0.65771294",
"0.64678746",
"0.6443204",
"0.64085907",
"0.6282923",
"0.6217106",
"0.62136954",
"0.6187679",
"0.61784613",
"0.6174508",
"0.6138206",
"0.6080813... | 0.0 | -1 |
end ........................................ Ruby will check the below condition, if the left side evaluates to false, it will check the right | def authenticate_agent(rank, name, credentials)
if (rank == "007" && name == "James Bond") || credentials == "Secret Agent"
puts "Access granted #{rank}, please proceed to the Intelligence Department"
else
puts "Access Denied"
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check ; true ; end",
"def conditionally_false\n\t\t!self\n\tend",
"def truth\n\t\t\t\"You can't handle the truth\" ; true\n\t\tend",
"def right?; end",
"def semact?; false; end",
"def left?; end",
"def cond; end",
"def cond; end",
"def cond; end",
"def condition; end",
"def right_optimizabl... | [
"0.6936507",
"0.68575704",
"0.68527347",
"0.6849671",
"0.6782816",
"0.6582656",
"0.65415657",
"0.65415657",
"0.65415657",
"0.65409833",
"0.6487943",
"0.6474126",
"0.64156556",
"0.64135027",
"0.6411398",
"0.64056283",
"0.63826495",
"0.636736",
"0.6367347",
"0.6332303",
"0.6315... | 0.0 | -1 |
puts "no" == "yes" ? "The two are equal!" : "No, it's not!" | def even_or_odd(num)
num.even? ? "That is an even number" : "That number is not even"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yesno(s)\n puts s ? 'yes' : 'no'\n end",
"def police_trouble(a,b)\n if (a == b)\n puts \"True\"\n else\n puts \"False\"\n end \nend",
"def yes_or_no(value = false)\n value ? \"Yes\" : \"No\"\n end",
"def yes_no(bool)\n case bool\n when 1\n \"yes\"\n when 0\n \"no\"\n ... | [
"0.7822539",
"0.6488336",
"0.6362433",
"0.63503087",
"0.6285073",
"0.6281771",
"0.62084436",
"0.6184067",
"0.61600274",
"0.61078095",
"0.6103081",
"0.6081749",
"0.60766774",
"0.60741687",
"0.60286015",
"0.6021307",
"0.6020903",
"0.59779936",
"0.5944606",
"0.5943364",
"0.59258... | 0.5524312 | 88 |
end .............Default or Optional Parameters.............. | def make_phone_call(number, international_code = 1, area_code = 646)
puts "Calling #{international_code}-#{area_code}-#{number}"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parameters; end",
"def parameters; end",
"def parameters; end",
"def parameters; end",
"def parameters; end",
"def parameters; end",
"def parameters; end",
"def parameters; end",
"def param; end",
"def param; end",
"def params; end",
"def params; end",
"def params; end",
"def params; ... | [
"0.77413565",
"0.77413565",
"0.77413565",
"0.77413565",
"0.77413565",
"0.77413565",
"0.77413565",
"0.77413565",
"0.75997204",
"0.75997204",
"0.73067325",
"0.73067325",
"0.73067325",
"0.73067325",
"0.73067325",
"0.73067325",
"0.73067325",
"0.73067325",
"0.73067325",
"0.73067325"... | 0.0 | -1 |
.....................Call a Method from another Method.......... | def add(a, b)
a + b
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def call() end",
"def call; end",
"def call; end",
"def call; end",
"def call; end",
"def call; end",
"def call; end",
"def call; end",
"def call; end",
"def calls; end",
"def calls; end",
"def call\n\n\tend",
"def call\n\n\tend",
"def invoke; end",
"def method\n\t\t# code code\n\tend",... | [
"0.74964064",
"0.7403404",
"0.7403404",
"0.7403404",
"0.7403404",
"0.7403404",
"0.7403404",
"0.7403404",
"0.7403404",
"0.7371763",
"0.7371763",
"0.7340971",
"0.7340971",
"0.71927637",
"0.71816385",
"0.71280164",
"0.70827204",
"0.7043805",
"0.70285016",
"0.70285016",
"0.702343... | 0.0 | -1 |
replicate the given item ID on an additional node | def replicate_once(item_id)
current_nodes = find_nodes(item_id)
possible_nodes = @master.data_nodes.values.select {|n| not current_nodes.include?(n)}
target_node = possible_nodes[(rand * possible_nodes.size).floor]
begin
current_nodes[0].replicate_data(item_id, target_node)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replicate_node(node_id)\n data_to_replicate = get_data_list(node_id)\n data_to_replicate.each do |data_id|\n replicate(data_id)\n end\n end",
"def add_replica(item_id, target_node, recovery_mode = false)\n# @logger.log_add_replica(item_id, Marshal.dump(target_node)) unless recov... | [
"0.780044",
"0.653256",
"0.60542476",
"0.6004983",
"0.59656054",
"0.59132254",
"0.5910546",
"0.5844275",
"0.58354086",
"0.5812551",
"0.5811051",
"0.58055866",
"0.57606685",
"0.57511157",
"0.5748595",
"0.57362896",
"0.5730767",
"0.57136625",
"0.56880325",
"0.56879205",
"0.5683... | 0.7394588 | 1 |
find all nodes this item ID is currently stored on | def find_nodes(item_id)
return @data_to_nodes[item_id]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nodes\n nodes_by_id.values\n end",
"def get_all_items\n items(@nodename)\n end",
"def all\n Directory.all.map do |node_id|\n find node_id\n end\n end",
"def nodes\n\t\t# Query the database\n\t\tnodeQuery = Node.select(:node_id)\n\t\t# Place the query in an array\n\t\tn... | [
"0.73976517",
"0.6829159",
"0.6678692",
"0.65628386",
"0.64820445",
"0.64217794",
"0.6364471",
"0.636337",
"0.63535976",
"0.63535976",
"0.6306287",
"0.6255241",
"0.6129386",
"0.6109872",
"0.60937876",
"0.60849595",
"0.60497683",
"0.60355353",
"0.60184646",
"0.5997937",
"0.596... | 0.78986424 | 0 |
choose the next node to replicate on | def next_replica
return @master.data_nodes[@master.data_nodes.keys[(rand * @master.data_nodes.size).floor]]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def node_at(index)\n node = head\n index.times { node = node.next_node }\n node\n end",
"def get_next_node(node)\n i = node.number + 1\n i = 0 if i >= nodes.size\n get_node(i)\n end",
"def go_to_next(rng)\n choice = rng.rand(0...@neighbors.size)\n @neighbors[choice]\n ... | [
"0.6514668",
"0.6421571",
"0.6368228",
"0.6344465",
"0.6340192",
"0.6325491",
"0.6226159",
"0.62227464",
"0.6169168",
"0.611879",
"0.60579425",
"0.6012685",
"0.5968307",
"0.5967144",
"0.5964623",
"0.5961795",
"0.5956632",
"0.5930374",
"0.590164",
"0.5901462",
"0.5897588",
"... | 0.624754 | 6 |
replicate all data on a node | def replicate_node(node_id)
data_to_replicate = get_data_list(node_id)
data_to_replicate.each do |data_id|
replicate(data_id)
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replicate_once(item_id)\n current_nodes = find_nodes(item_id)\n possible_nodes = @master.data_nodes.values.select {|n| not current_nodes.include?(n)}\n target_node = possible_nodes[(rand * possible_nodes.size).floor]\n \n begin\n current_nodes[0].replicate_data(item_id, target_n... | [
"0.699328",
"0.6991535",
"0.6089273",
"0.60508937",
"0.6039473",
"0.5968721",
"0.5853404",
"0.58148897",
"0.5768634",
"0.57670987",
"0.5750188",
"0.57152104",
"0.5705888",
"0.5638921",
"0.56120044",
"0.5598138",
"0.55959207",
"0.55907553",
"0.55842155",
"0.5553286",
"0.550234... | 0.8124062 | 0 |
get the list of data elements stored on this node | def get_data_list(node_id)
if @nodes_to_data[node_id].nil?
return []
else
return @nodes_to_data[node_id]
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_node_data()\n return @node_data\n end",
"def list_data\n _check_and_get(@_data, Array)\n end",
"def all_data\n @data\n end",
"def to_a\n collect { |node| node.data }\n end",
"def all\n return @data\n end",
"def all\n return @data\n end",
"... | [
"0.69746375",
"0.6967763",
"0.6935135",
"0.6915528",
"0.6805751",
"0.6805751",
"0.6731588",
"0.66621655",
"0.66082394",
"0.6561876",
"0.6561876",
"0.6561876",
"0.65204203",
"0.64814293",
"0.64812005",
"0.6471252",
"0.6431633",
"0.64258343",
"0.64151",
"0.63963366",
"0.6391301... | 0.6840105 | 4 |
mark this item as stored at this node | def add_replica(item_id, target_node, recovery_mode = false)
# @logger.log_add_replica(item_id, Marshal.dump(target_node)) unless recovery_mode
if @nodes_to_data[target_node].nil?
@nodes_to_data[target_node] = [item_id]
else
@nodes_to_data[target_node] = @nodes_to_data[target_node] << i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set(item, node)\n\t\t\t@hash[item] = node\n\t\tend",
"def mark\n @temp = @push\n @mark = @index\n end",
"def node=(node)\n items_node[:node] = node\n end",
"def set_item(item)\n return if @item == item\n @item = item\n refresh\n end",
"def set_item(item)\n ... | [
"0.6731198",
"0.62898755",
"0.6254815",
"0.624817",
"0.624817",
"0.6192102",
"0.6042183",
"0.6020909",
"0.5948556",
"0.5917509",
"0.5853266",
"0.5846719",
"0.58341926",
"0.58221734",
"0.57944095",
"0.57898515",
"0.5775122",
"0.5738727",
"0.5723727",
"0.5718844",
"0.5709879",
... | 0.0 | -1 |
remove the metadata info about this item, it's no longer needed. | def clear_replicas(item_id, recovery_mode = false)
# @logger.log_clear_replicas(item_id) unless recovery_mode
nodes = find_nodes(item_id)
nodes.each do |node|
@nodes_to_data[node].delete(item_id)
end
@data_to_nodes.delete(item_id)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove!\n MiGA.DEBUG \"Metadata.remove! #{path}\"\n File.unlink(path)\n nil\n end",
"def remove!\n self.results.each{ |r| r.remove! }\n self.metadata.remove!\n end",
"def remove_item(item)\r\n items.delete(item)\r\n item.owner = nil\r\n end",
"def del_meta(name)\n _manage... | [
"0.68260854",
"0.6648593",
"0.6592068",
"0.65913236",
"0.6546396",
"0.6363503",
"0.6240255",
"0.621463",
"0.6200061",
"0.6136708",
"0.61334115",
"0.611737",
"0.61117536",
"0.6071198",
"0.60455155",
"0.6036215",
"0.60284984",
"0.60149527",
"0.6010991",
"0.6005475",
"0.59993416... | 0.0 | -1 |
Replace this with your real tests. | def test_truth
assert_kind_of Picture, pictures(:first)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testing\n # ...\n end",
"def __dummy_test__\n end",
"def tests; end",
"def tests; end",
"def spec; end",
"def spec; end",
"def self_test; end",
"def self_test; end",
"def test \n end",
"def test_0_dummy\n\t\tend",
"def test\n\n end",
"def test\n end",
"def test\n end"... | [
"0.7446459",
"0.6956364",
"0.69155836",
"0.69155836",
"0.6864151",
"0.6864151",
"0.66406286",
"0.66406286",
"0.66253287",
"0.6547665",
"0.6524571",
"0.6484549",
"0.6484549",
"0.6484549",
"0.6403847",
"0.6389188",
"0.6389188",
"0.6389188",
"0.6389188",
"0.6389188",
"0.6389188"... | 0.0 | -1 |
GET /po_receipts GET /po_receipts.json | def home
#sleep(60)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def receipts_plist\n plist_virtual_attribute_get(:receipts)\n end",
"def index\n @receipts = current_account.receipts.all\n end",
"def showReceipt\n render json: Approved.findReceipt(params[\"id\"])\n end",
"def index\n @receipts = current_user.receipts\n end",
"def index\n @re... | [
"0.6986946",
"0.6897085",
"0.6842668",
"0.67751515",
"0.6733184",
"0.6731087",
"0.6696973",
"0.6615695",
"0.6485501",
"0.6407677",
"0.63738376",
"0.63600856",
"0.63300115",
"0.63208663",
"0.6277574",
"0.6255837",
"0.62501556",
"0.62271374",
"0.62058103",
"0.6194002",
"0.61882... | 0.0 | -1 |
GET /po_receipts/1 GET /po_receipts/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def showReceipt\n render json: Approved.findReceipt(params[\"id\"])\n end",
"def receipts_plist\n plist_virtual_attribute_get(:receipts)\n end",
"def index\n @receipts = current_account.receipts.all\n end",
"def index\n @receipts = Receipt.status_based_receipts(params[:receipt_status... | [
"0.6875864",
"0.68286467",
"0.65048707",
"0.6447613",
"0.64221716",
"0.6376781",
"0.6372004",
"0.63661253",
"0.6353669",
"0.634854",
"0.62733674",
"0.6228477",
"0.6201489",
"0.6172263",
"0.61586636",
"0.61450446",
"0.61346877",
"0.61068964",
"0.60977864",
"0.60884005",
"0.605... | 0.0 | -1 |
POST /po_receipts POST /po_receipts.json | def create
@po_receipt = PoReceipt.new(po_receipt_params)
respond_to do |format|
if @po_receipt.save
format.html { redirect_to @po_receipt, notice: 'Po receipt was successfully created.' }
format.json { render :show, status: :created, location: @po_receipt }
else
format.html... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post_receipt(atom)\n form_data = { application: @application_name }\n @hive_party.post \"/atoms/#{atom.id}/receipts\", form_data\n end",
"def sms_receipts_post(url, opts = {})\n data, _status_code, _headers = sms_receipts_post_with_http_info(url, opts)\n data\n end",
"def create\n... | [
"0.721813",
"0.67675304",
"0.6680944",
"0.6589276",
"0.65421957",
"0.65368307",
"0.6452098",
"0.6452098",
"0.6449987",
"0.63635993",
"0.6341161",
"0.6330778",
"0.6267977",
"0.62663114",
"0.6241786",
"0.6206461",
"0.61965257",
"0.61912036",
"0.61812663",
"0.61712927",
"0.61522... | 0.7144056 | 1 |
PATCH/PUT /po_receipts/1 PATCH/PUT /po_receipts/1.json | def update
respond_to do |format|
if @po_receipt.update(po_receipt_params)
format.html { redirect_to @po_receipt, notice: 'Po receipt was successfully updated.' }
format.json { render :show, status: :ok, location: @po_receipt }
else
format.html { render :edit }
format.jso... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @receipt = current_user.receipts.find(params[:id])\n respond_to do |format|\n if @receipt.update(receipt_params)\n format.html { redirect_to @receipt, notice: 'Receipt was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render act... | [
"0.663678",
"0.6530603",
"0.6501283",
"0.6446072",
"0.6438361",
"0.6438137",
"0.6438137",
"0.64157146",
"0.634435",
"0.6319594",
"0.6273267",
"0.62509465",
"0.620919",
"0.61912376",
"0.6097274",
"0.6086628",
"0.6084257",
"0.60782176",
"0.6029632",
"0.6028742",
"0.59962356",
... | 0.7156478 | 0 |
DELETE /po_receipts/1 DELETE /po_receipts/1.json | def destroy
lifnr = @po_receipt.lifnr
lifdn = @po_receipt.lifdn
werks = @po_receipt.werks
@po_receipt.destroy
respond_to do |format|
format.html { redirect_to po_receipts_url(lifnr: lifnr, lifdn: lifdn, werks: werks) }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @receipt = Receipt.find(params[:id])\n @receipt.destroy\n\n respond_to do |format|\n format.html { redirect_to receipts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @receipt.destroy\n respond_to do |format|\n format.html { redirect_to recei... | [
"0.7249442",
"0.7205277",
"0.71285504",
"0.7062397",
"0.70389324",
"0.702607",
"0.69623387",
"0.6948784",
"0.6899735",
"0.68326765",
"0.68326765",
"0.68326765",
"0.67873055",
"0.67733824",
"0.6762464",
"0.6696877",
"0.66483766",
"0.66245335",
"0.66068006",
"0.66017556",
"0.65... | 0.7292007 | 0 |
Use callbacks to share common setup or constraints between actions. | def set_po_receipt
@po_receipt = PoReceipt.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_... | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576"... | 0.0 | -1 |
Never trust parameters from the scary internet, only allow the white list through. | def po_receipt_params
params.require(:po_receipt).permit(:uuid, :barcode, :vtweg, :lifnr, :lifdn, :matnr, :werks, :pkg_no, :date_code, :mfg_date, :menge, :alloc_qty, :balqty, :status, :vtype, :impnr, :charg, :remote_ip, :creator, :updater)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n... | [
"0.6980384",
"0.6782743",
"0.6746196",
"0.6742575",
"0.6736",
"0.6594004",
"0.65037984",
"0.6496699",
"0.64819324",
"0.64791185",
"0.6456292",
"0.64403296",
"0.63795286",
"0.6375975",
"0.6365291",
"0.63210756",
"0.6300542",
"0.6299717",
"0.62943304",
"0.6292561",
"0.6290683",... | 0.0 | -1 |
GET /spiders GET /spiders.json | def index
@spiders = Spider.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def listspiders(project=self.project)\n get('listspiders.json', project: project)['spiders']\n end",
"def index\n\t\t@pipelines = Pipeline.all(include: :stages)\n\n\t\trespond_to do |format|\n\t\t\tformat.html # index.html.erb\n\t\t\tformat.json { render json: @pipelines }\n\t\tend\n\tend",
"def index\n ... | [
"0.7527467",
"0.578524",
"0.5602479",
"0.5582062",
"0.55442256",
"0.554001",
"0.554001",
"0.5492717",
"0.54835296",
"0.5453081",
"0.54461664",
"0.5442363",
"0.54386324",
"0.538377",
"0.5317914",
"0.53159386",
"0.5291303",
"0.5291303",
"0.5289522",
"0.528471",
"0.5277389",
"... | 0.7576435 | 0 |
GET /spiders/1 GET /spiders/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @spiders = Spider.all\n end",
"def listspiders(project=self.project)\n get('listspiders.json', project: project)['spiders']\n end",
"def show\n @rider = Rider.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @rider }\n ... | [
"0.7207449",
"0.70266545",
"0.56690043",
"0.56690043",
"0.56281745",
"0.5612165",
"0.55994374",
"0.5563946",
"0.5540704",
"0.54717034",
"0.5458986",
"0.54572767",
"0.54251295",
"0.5420087",
"0.54197514",
"0.54171497",
"0.5381326",
"0.5380862",
"0.53777814",
"0.5371228",
"0.53... | 0.0 | -1 |
POST /spiders POST /spiders.json | def create
@spider = Spider.new(spider_params)
respond_to do |format|
if @spider.save
format.html { redirect_to @spider, notice: 'Spider was successfully created.' }
format.json { render :show, status: :created, location: @spider }
else
format.html { render :new }
fo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @spiders = Spider.all\n end",
"def listspiders(project=self.project)\n get('listspiders.json', project: project)['spiders']\n end",
"def spider_params\n params.require(:spider).permit(:name, :container_id, :status, :image_id, :prefix, :frequency, :run_info, :max_memory)\n end",
"d... | [
"0.65026385",
"0.6009115",
"0.57850796",
"0.55037534",
"0.54188097",
"0.5372787",
"0.53106445",
"0.53051174",
"0.52793837",
"0.5213296",
"0.5197774",
"0.51752377",
"0.5118427",
"0.5107348",
"0.510598",
"0.51013225",
"0.50770897",
"0.50742877",
"0.5062011",
"0.49972507",
"0.49... | 0.6690364 | 0 |
PATCH/PUT /spiders/1 PATCH/PUT /spiders/1.json | def update
respond_to do |format|
if @spider.update(spider_params)
format.html { redirect_to @spider, notice: 'Spider was successfully updated.' }
format.json { render :show, status: :ok, location: @spider }
else
format.html { render :edit }
format.json { render json: @sp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patch!\n request! :patch\n end",
"def patch\n headers = {\"If-Match\" => @version}\n response = @context.request :patch, \"#{@path}/#{@id}\", @data.to_json, headers\n @version += 1\n response\n # 'X-HTTP-Method-Override' => 'PATCH'\n end",
"def update(url, data)\n Rest... | [
"0.60661185",
"0.5957777",
"0.5957616",
"0.5947359",
"0.5903018",
"0.59004456",
"0.5881387",
"0.5865824",
"0.58632433",
"0.5799487",
"0.5793312",
"0.5738856",
"0.57338053",
"0.5730968",
"0.56914645",
"0.56741804",
"0.5652866",
"0.56454325",
"0.56349313",
"0.55989033",
"0.5591... | 0.5858193 | 9 |
DELETE /spiders/1 DELETE /spiders/1.json | def destroy
@spider.destroy
respond_to do |format|
format.html { redirect_to spiders_url, notice: 'Spider was successfully destroyed.' }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @go_slim = GoSlim.find(params[:id])\n @go_slim.destroy\n\n respond_to do |format|\n format.html { redirect_to go_slims_url }\n format.json { head :no_content }\n end\n end",
"def delete\n client.delete(\"/#{id}\")\n end",
"def delete(path)\n RestClient.delete r... | [
"0.6548",
"0.64675266",
"0.6307504",
"0.62991554",
"0.6270885",
"0.62647176",
"0.6261972",
"0.62554896",
"0.62056506",
"0.6178789",
"0.61371577",
"0.6125963",
"0.6096617",
"0.6096617",
"0.60804516",
"0.60776794",
"0.60740256",
"0.60643065",
"0.6057096",
"0.6054811",
"0.604914... | 0.6931202 | 0 |
Use callbacks to share common setup or constraints between actions. | def set_spider
@spider = Spider.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_... | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576"... | 0.0 | -1 |
Only allow a list of trusted parameters through. | def spider_params
params.require(:spider).permit(:name, :container_id, :status, :image_id, :prefix, :frequency, :run_info, :max_memory)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def allowed_params\n ALLOWED_PARAMS\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def parameters_list_params\n params.require(:parameters_list).permit(:name, :description, :is_user_specific)\n end",
"def param_whitelist\n [:role, :title]\... | [
"0.69497335",
"0.6812623",
"0.6803639",
"0.6795365",
"0.67448795",
"0.67399913",
"0.6526815",
"0.6518771",
"0.64931697",
"0.6430388",
"0.6430388",
"0.6430388",
"0.63983387",
"0.6356042",
"0.63535863",
"0.63464934",
"0.63444513",
"0.6337208",
"0.6326454",
"0.6326454",
"0.63264... | 0.0 | -1 |
takes num returns many num | def fibs(num)
arry = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]
arry[num]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def magic_numbers(count)\nend",
"def numbers(n)\n\nend",
"def many_results(n)\r\n\treturn 1, n /2, n\r\nend",
"def multiples(num)\n\tresult = []\n\tsum = 0\n\ti = 1\n\twhile i < num\n\t\tif i % 3 == 0 || i % 5 == 0\n\t\t\tresult << i\n\t\tend\n\t\ti += 1\n\tend\n\tresult.each do |digit|\n\t\tsum += digit\n\t... | [
"0.72358567",
"0.7193444",
"0.69431883",
"0.6741622",
"0.6658723",
"0.6616837",
"0.6594157",
"0.6535502",
"0.6506408",
"0.64606684",
"0.6448966",
"0.6433005",
"0.63878816",
"0.636836",
"0.6358029",
"0.6356467",
"0.6346895",
"0.634617",
"0.6345477",
"0.6328723",
"0.6321861",
... | 0.0 | -1 |
GET /publications GET /publications.json | def index
@publications = Publication.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n if @author_id\n @publications = @author.publications\n else\n @publications = Publication.all\n end\n render json: @publications\n end",
"def publications\n @publications = Publication.all\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { ... | [
"0.793708",
"0.7693545",
"0.73052156",
"0.71499056",
"0.710067",
"0.70662844",
"0.70455796",
"0.6991772",
"0.6912951",
"0.68665963",
"0.68345994",
"0.6816118",
"0.6789779",
"0.6753457",
"0.66966105",
"0.6667548",
"0.66633326",
"0.66335666",
"0.6605103",
"0.6571169",
"0.654839... | 0.7443663 | 5 |
POST /publications POST /publications.json | def create
@publication = Publication.new(publication_params)
respond_to do |format|
if @publication.save
format.html { redirect_to publications_url, notice: 'Publication was successfully created.' }
format.json { render :show, status: :created, location: @publication }
else
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @publication = Publication.new(publication_params)\n\n if @publication.save\n render json: @publication, status: :created\n else\n reponse = { status: \"error\", code: 422,\n message: \"couldn't create the publication\",\n errors: @publication.error... | [
"0.7351526",
"0.7222527",
"0.7222527",
"0.7187896",
"0.7085576",
"0.70243484",
"0.6952572",
"0.6914492",
"0.6897696",
"0.68479717",
"0.6800644",
"0.6797221",
"0.6747078",
"0.6727789",
"0.67252874",
"0.6698838",
"0.6681279",
"0.66702557",
"0.66583014",
"0.6594258",
"0.6580721"... | 0.7260106 | 1 |
PATCH/PUT /publications/1 PATCH/PUT /publications/1.json | def update
respond_to do |format|
if @publication.update(publication_params)
format.html { redirect_to publications_url, notice: 'Publication was successfully updated.' }
format.json { render :show, status: :ok, location: @publication }
else
format.html { render :edit }
f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n logger.info('PUT Update:')\n logger.info(request_body)\n new_pub = hashed_request\n old_pub = Publication.find_by(id: params[:id])\n if old_pub.blank?\n head :not_found\n return\n elsif old_pub.deleted?\n head :gone\n return\n end\n if old_pub.harvested_pub?... | [
"0.7181202",
"0.7017134",
"0.68675035",
"0.67795646",
"0.67539096",
"0.67428213",
"0.67428213",
"0.67428213",
"0.671077",
"0.6670905",
"0.66663516",
"0.65363234",
"0.6523172",
"0.6493263",
"0.64796525",
"0.6436615",
"0.638798",
"0.63537747",
"0.6313768",
"0.6308919",
"0.62913... | 0.6731068 | 8 |
DELETE /publications/1 DELETE /publications/1.json | def destroy
@publication.destroy
respond_to do |format|
format.html { redirect_to publications_url, notice: 'Publication was successfully destroyed.' }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @publication.destroy\n respond_to do |format|\n format.html { redirect_to publications_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @publication.destroy\n respond_to do |format|\n format.html { redirect_to publications_url }\n format.json... | [
"0.78301245",
"0.78301245",
"0.7801926",
"0.7751558",
"0.7702748",
"0.76973265",
"0.7599814",
"0.7575114",
"0.75505936",
"0.7549252",
"0.75462687",
"0.7530383",
"0.75106543",
"0.7419731",
"0.7398968",
"0.73864627",
"0.7363567",
"0.7351437",
"0.72758895",
"0.7194398",
"0.71791... | 0.75696844 | 10 |
Use callbacks to share common setup or constraints between actions. | def set_publication
@publication = Publication.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_... | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576"... | 0.0 | -1 |
Never trust parameters from the scary internet, only allow the white list through. | def publication_params
params.require(:publication).permit(:bib, person_ids: [], project_ids: [])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n... | [
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",... | 0.0 | -1 |
require all new entries to have these four fields, at a minimum, INCLUDING notes | def result_check
params.require(:result).permit(:name,
:costinusd,
:aacostpts,
:aacostusd,
:bacostpts,
:bacostusd,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_required_fields\n user = new_record? ? author : current_journal.try(:user)\n\n required_attribute_names(user).each do |attribute|\n if /^\\d+$/.match?(attribute)\n attribute = attribute.to_i\n v = custom_field_values.detect {|v| v.custom_field_id == attribute}\n if v &&... | [
"0.6091969",
"0.5979381",
"0.5979381",
"0.595067",
"0.5946971",
"0.5915128",
"0.58852035",
"0.58462495",
"0.5815208",
"0.5805569",
"0.566186",
"0.5607317",
"0.56022465",
"0.55788034",
"0.5549925",
"0.55423266",
"0.55375445",
"0.54914427",
"0.5489911",
"0.54780114",
"0.5477048... | 0.0 | -1 |
GET /crossword_puzzles/1 GET /crossword_puzzles/1.json | def show
@crossword_puzzle = CrosswordPuzzle.find(params[:id])
#Creates a solution for the puzzle by the user
unless (current_user.nil? || @crossword_puzzle.nil?)
@crossword_solution = CrosswordSolution.find_or_create_by_user_id_and_crossword_puzzle_id(current_user.id, @crossword_puzzle.id)
end
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @puzzles = Puzzle.order :name\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @puzzles }\n end\n end",
"def new\n @crossword_puzzle = CrosswordPuzzle.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { ... | [
"0.6225021",
"0.60576874",
"0.5939479",
"0.5932435",
"0.5921396",
"0.58294564",
"0.58211523",
"0.57480085",
"0.56797725",
"0.5666099",
"0.56627667",
"0.56585425",
"0.5646442",
"0.55696684",
"0.5558909",
"0.5556609",
"0.54991317",
"0.54934365",
"0.54934365",
"0.54934365",
"0.5... | 0.5740075 | 8 |
GET /crossword_puzzles/new GET /crossword_puzzles/new.json | def new
@crossword_puzzle = CrosswordPuzzle.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @crossword_puzzle }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n @paper_word = PaperWord.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @paper_word }\n end\n end",
"def new\n @word = Word.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @word }\n ... | [
"0.6949752",
"0.68672717",
"0.68672717",
"0.68672717",
"0.68672717",
"0.68672717",
"0.6809923",
"0.6769404",
"0.6591035",
"0.6575545",
"0.65729815",
"0.65692127",
"0.6555466",
"0.65527725",
"0.65492034",
"0.6518632",
"0.64954877",
"0.6488429",
"0.6487212",
"0.6472325",
"0.647... | 0.71602786 | 0 |
POST /crossword_puzzles POST /crossword_puzzles.json | def create
@crossword_puzzle = CrosswordPuzzle.new(params[:crossword_puzzle])
if !@crossword_puzzle.user && current_user
@crossword_puzzle.user = current_user
end
respond_to do |format|
if @crossword_puzzle.save
if current_user.admin
format.html { redirect_to @crossword_puzzle, n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @paper_word = PaperWord.new(params[:paper_word])\n\n respond_to do |format|\n if @paper_word.save\n format.html { redirect_to @paper_word, notice: 'Paper word was successfully created.' }\n format.json { render json: @paper_word, status: :created, location: @paper_word }\n ... | [
"0.59651744",
"0.55942965",
"0.5541964",
"0.54664713",
"0.54053706",
"0.54040056",
"0.54001254",
"0.5396807",
"0.5380307",
"0.5374924",
"0.53667176",
"0.5311728",
"0.53114116",
"0.53114116",
"0.5309286",
"0.5309286",
"0.5309286",
"0.53056145",
"0.5303603",
"0.5296149",
"0.528... | 0.59659815 | 0 |
PUT /crossword_puzzles/1 PUT /crossword_puzzles/1.json | def update
@crossword_puzzle = CrosswordPuzzle.find(params[:id])
respond_to do |format|
if @crossword_puzzle.update_attributes(params[:crossword_puzzle])
format.html { redirect_to edit_crossword_puzzle_path(@crossword_puzzle), notice: 'Puzzle saved!' }
format.json { head :no_content }
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @word = Word.find(params[:id])\n\n respond_to do |format|\n\n if @word.update_attributes(params[:word])\n format.json { head :no_content }\n else\n format.json { render :json => @word.errors,\n :status => :unprocessable_entity }\n end\n... | [
"0.6003195",
"0.5832756",
"0.57551366",
"0.5728726",
"0.56529737",
"0.56529737",
"0.56529737",
"0.56529737",
"0.56218475",
"0.5549136",
"0.55422103",
"0.55068344",
"0.549347",
"0.54843426",
"0.54843426",
"0.54843426",
"0.54843426",
"0.54843426",
"0.54679215",
"0.5455668",
"0.... | 0.6163839 | 0 |
DELETE /crossword_puzzles/1 DELETE /crossword_puzzles/1.json | def destroy
@crossword_puzzle = CrosswordPuzzle.find(params[:id])
@crossword_puzzle.destroy
respond_to do |format|
if current_user.admin
format.html { redirect_to crossword_puzzles_url, notice: 'Puzzle successfully deleted.' }
else
format.html { redirect_to root_url, notice: 'Crossword ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @paper_word = PaperWord.find(params[:id])\n @paper_word.destroy\n\n respond_to do |format|\n format.html { redirect_to paper_words_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @word_praat.destroy\n respond_to do |format|\n format.html { red... | [
"0.68856907",
"0.6765128",
"0.67376244",
"0.67296416",
"0.6724661",
"0.6724661",
"0.6724661",
"0.6724661",
"0.6724661",
"0.67044264",
"0.6696909",
"0.6656563",
"0.6653519",
"0.6628278",
"0.662076",
"0.6617038",
"0.6613154",
"0.661139",
"0.65942556",
"0.6590585",
"0.65708786",... | 0.6478811 | 33 |
Uses player input to determine the battle command. | def choose_attack
print_battle_commands(header = "Choose an attack:")
input = player_input
index = has_battle_command(input)
#input error loop
while !index
puts "You don't have '#{input}'"
print_battle_commands(header = "Try one of these:")
input = player_input
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def phase2_command_input \r\n # Play decision SE\r\n $game_system.se_play($data_system.decision_se)\r\n # Branch by party command window cursor position\r\n case @party_command_window.command\r\n when SDK::Scene_Commands::Scene_Battle::Fight # fight\r\n phase2_command_fight\r\n when SDK::... | [
"0.70609623",
"0.70355",
"0.6947934",
"0.68862426",
"0.6633459",
"0.661562",
"0.6567215",
"0.6544181",
"0.6514603",
"0.6471352",
"0.6465121",
"0.6387266",
"0.63676935",
"0.63569516",
"0.63325167",
"0.62914205",
"0.62868357",
"0.62705934",
"0.6267516",
"0.626027",
"0.6252274",... | 0.6792389 | 4 |
Requires input to select item and on whom to use it during battle (Use command). Return nil on error. | def choose_item_and_on_whom(enemy)
index = nil
item = nil
# Choose the item to use.
while !index
print_inventory
puts "Which item would you like to use?"
input = player_input prompt: "(or type 'pass' to forfeit the turn): "
return if (input.casecmp("pass").zero?... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def use_item\n\n if @inventory.empty?\n slow_type(\"\\nYou don't have anything in your inventory\")\n\n else\n print_inventory_items\n\n use_item = TTY::Prompt.new\n\n choices = []\n @options = []\n @inventory.each do |item_id|\n inventory_item = find_item_by_id(item_id)\n ... | [
"0.7295352",
"0.66059655",
"0.64451236",
"0.64365077",
"0.62689704",
"0.6259953",
"0.61984205",
"0.6178161",
"0.6145603",
"0.6133078",
"0.61178565",
"0.6101897",
"0.6096184",
"0.60942155",
"0.6093194",
"0.6092084",
"0.6084433",
"0.60492486",
"0.60466254",
"0.604445",
"0.60262... | 0.6303358 | 4 |
Sends the player back to a safe location, halves its gold, and restores HP. | def die
sleep(2) unless ENV['TEST']
# TODO: fix next line. regen_location could be nil or "bad."
@location = @map.regen_location
type("After being knocked out in battle,\n")
type("you wake up in #{@map.name}.\n\n")
sleep(2) unless ENV['TEST']
# Heal the player.
set_st... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kick(player_name)\n\t\n\t player_name.hp = player_name.hp - 20\n\n\t end",
"def die\n sleep(2) unless ENV['TEST']\n\n # TODO: fix next line. regen_location could be nil or \"bad.\"\n @location = @map.regen_location\n\n type(\"After being knocked out in battle,\\n\")\n type(\"you wake up in #{... | [
"0.644188",
"0.6198938",
"0.61366934",
"0.6132904",
"0.6065919",
"0.6029237",
"0.6009856",
"0.5991272",
"0.5988335",
"0.5912267",
"0.5909582",
"0.589586",
"0.5866175",
"0.5858791",
"0.5850262",
"0.58336574",
"0.58141494",
"0.5796272",
"0.57941866",
"0.5787628",
"0.5782212",
... | 0.6135624 | 3 |
Moves the player down. Increases 'y' coordinate by 1. | def move_down
down_tile = C[@location.first + 1, @location.second]
move_to(down_tile)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_down\r\n if @y + @vel_y < SCREEN_HEIGHT - GAME_PRESET[\"player_move_down\"]\r\n @y += @vel_y\r\n end\r\n end",
"def move_down(n)\n self.y -= n\n end",
"def move_up\n\t\tunless @y_player <= 0\n\t\t\t@y_player -= 4\n\t\tend\n\tend",
"def move_down(turn_enabled = true)\n @y += 1 ... | [
"0.84450954",
"0.7647884",
"0.73934776",
"0.73630226",
"0.73521405",
"0.72659457",
"0.71944845",
"0.71581674",
"0.71370125",
"0.70650494",
"0.7042545",
"0.68378377",
"0.6713143",
"0.6696204",
"0.6696204",
"0.6666921",
"0.66378856",
"0.6633491",
"0.66154736",
"0.65613794",
"0.... | 0.65976655 | 19 |
Moves the player left. Decreases 'x' coordinate by 1. | def move_left
left_tile = C[@location.first, @location.second - 1]
move_to(left_tile)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_left \r\n if @x - @vel_x > GAME_PRESET[\"player_move_left\"]\r\n @x -= @vel_x\r\n end\r\n end",
"def move_left\n\t\t@x_speed -= @speed_inc_step\n\t\tif @x_speed < -@max_speed\n\t\t\t@x_speed = -@max_speed\n\t\tend\n\n\t\tupdate_x(@x_speed)\n\n\t\tif !face_left?\n\t\t\tupdate_angle(calculate_ang... | [
"0.8338273",
"0.7785288",
"0.7763415",
"0.7679488",
"0.76286787",
"0.74821323",
"0.7165592",
"0.7136886",
"0.7124332",
"0.71148473",
"0.7034083",
"0.70095694",
"0.70095694",
"0.68827945",
"0.6868804",
"0.6846114",
"0.68417704",
"0.68364877",
"0.6707493",
"0.6672153",
"0.66629... | 0.62541634 | 55 |
Moves the player right. Increases 'x' coordinate by 1. | def move_right
right_tile = C[@location.first, @location.second + 1]
move_to(right_tile)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_right\r\n if @x + @vel_x < SCREEN_WIDTH - GAME_PRESET[\"player_move_right\"]\r\n @x += @vel_x\r\n end\r\n end",
"def move_right\n\t\tmove([1,0])\n\tend",
"def move_right\n\t\t@x_speed += @speed_inc_step\n\t\tif @x_speed > @max_speed\n\t\t\t@x_speed = @max_speed\n\t\tend\n\n\t\tupdate_x(@x_... | [
"0.84250695",
"0.7901699",
"0.77740717",
"0.7690245",
"0.74000055",
"0.73994577",
"0.7097265",
"0.708047",
"0.69408184",
"0.6901933",
"0.68985355",
"0.6881219",
"0.68619436",
"0.68537927",
"0.68376124",
"0.6835703",
"0.6835633",
"0.6802224",
"0.6797812",
"0.6797812",
"0.67708... | 0.6862269 | 12 |
Safe setter function for location and map. | def move_to(coordinates, map = @map)
# Prevents operations on nil.
return if map.nil?
y = coordinates.first; x = coordinates.second
# Save the map.
@saved_maps[@map.name] = @map if @map
# Even if the player hasn't moved, we still change to true.
# This is because we want to ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def location=(data)\n if self.location.present? && !data.is_a?(Hash)\n self.location.destroy\n end\n \n if data.is_a?(Hash)\n if self.location.present?\n self.location.attributes = data\n else\n super(Location.new data)\n end\n else\n super(data)\n end\n en... | [
"0.6912048",
"0.6796796",
"0.6522319",
"0.65150994",
"0.6451366",
"0.64149064",
"0.64078635",
"0.6237788",
"0.62025017",
"0.6188886",
"0.61868346",
"0.61010027",
"0.61008084",
"0.6091306",
"0.6064603",
"0.6060982",
"0.60591483",
"0.6056453",
"0.60199803",
"0.5998788",
"0.5974... | 0.0 | -1 |
Moves the player up. Decreases 'y' coordinate by 1. | def move_up
up_tile = C[@location.first - 1, @location.second]
move_to(up_tile)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_up\n\t\tunless @y_player <= 0\n\t\t\t@y_player -= 4\n\t\tend\n\tend",
"def move_up\r\n if @y + @vel_y > GAME_PRESET[\"player_move_up\"]\r\n @y -= @vel_y\r\n end\r\n end",
"def move_up\n unless @value.eql? 1\n @y -= 50\n @value -= 1\n end\n end",
"def move_up\n\t\t# if th... | [
"0.8473898",
"0.84681857",
"0.79214144",
"0.7700698",
"0.764459",
"0.7614573",
"0.75507265",
"0.74856675",
"0.74225557",
"0.72708976",
"0.7248377",
"0.7061182",
"0.6933274",
"0.6896247",
"0.68573534",
"0.68009686",
"0.674319",
"0.6737837",
"0.6666356",
"0.6657828",
"0.6623143... | 0.66657823 | 19 |
Prints the map in regards to what the player has seen. Additionally, provides current location and the map's name. | def print_map
# Provide some spacing from the edge of the terminal.
3.times { print " " };
print @map.name + "\n\n"
@map.tiles.each_with_index do |row, r|
# Provide spacing for the beginning of each row.
2.times { print " " }
row.each_with_index do |tile, t|
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_map\n\n # Provide some spacing to center the name.\n (0..(@map.name.length/4)).each do\n print \" \"\n end\n\n print @map.name + \"\\n\\n\"\n\n @map.tiles.each_with_index do |row, r|\n # Provide spacing for the beginning of each row.\n (0..(@map.name.length/2)).each do\n ... | [
"0.7134865",
"0.6895263",
"0.6881917",
"0.6813431",
"0.6575877",
"0.653626",
"0.64906824",
"0.647277",
"0.6420577",
"0.63627094",
"0.6360731",
"0.6260933",
"0.6221287",
"0.621146",
"0.6188618",
"0.61772645",
"0.61495423",
"0.6136092",
"0.6108629",
"0.61017257",
"0.60913604",
... | 0.7251592 | 0 |
Prints a minimap of nearby tiles (using VIEW_DISTANCE). | def print_minimap
print "\n"
for y in (@location.first-VIEW_DISTANCE)..(@location.first+VIEW_DISTANCE)
# skip to next line if out of bounds from above map
next if y.negative?
# centers minimap
10.times { print " " }
for x in (@location.second-VIEW_DISTANCE)..(@locatio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_minimap\n print \"\\n\"\n for y in (@location.first-VIEW_DISTANCE)..(@location.first+VIEW_DISTANCE)\n # skip to next line if out of bounds from above map\n next if y < 0\n # centers minimap\n 10.times do\n print \" \"\n end\n for x in (@location.second-VIEW_DIST... | [
"0.83357704",
"0.6402761",
"0.62895626",
"0.62808174",
"0.6154004",
"0.6044166",
"0.60214835",
"0.5905696",
"0.5888686",
"0.58621854",
"0.57700944",
"0.5757397",
"0.57502127",
"0.5732081",
"0.5726335",
"0.5725984",
"0.570613",
"0.5668745",
"0.5655546",
"0.56177217",
"0.558181... | 0.8136597 | 1 |
Prints the tile based on the player's location. | def print_tile(coords)
if ((@location.first == coords.first) && (@location.second == coords.second))
print "¶ "
else
print @map.tiles[coords.first][coords.second].to_s
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_tile(coords)\n if ((@location.first == coords.first) && (@location.second == coords.second))\n print \"¶ \"\n else\n print @map.tiles[coords.first][coords.second].to_s\n end\n end",
"def show_player\n if @position == 1\n puts \"le joueur #{@position} : #{@name.capitalize} #{... | [
"0.7665916",
"0.6691956",
"0.65180314",
"0.6510894",
"0.6468359",
"0.6464139",
"0.6356246",
"0.63491505",
"0.63429517",
"0.629416",
"0.62820613",
"0.6255598",
"0.6245893",
"0.62337184",
"0.6218377",
"0.62048995",
"0.61825913",
"0.6175415",
"0.61319804",
"0.612568",
"0.6121357... | 0.764693 | 1 |
Updates the 'seen' attributes of the tiles on the player's current map. | def update_map(coordinates = @location)
for y in (coordinates.first-VIEW_DISTANCE)..(coordinates.first+VIEW_DISTANCE)
for x in (coordinates.second-VIEW_DISTANCE)..(coordinates.second+VIEW_DISTANCE)
@map.tiles[y][x].seen = true if (@map.in_bounds(y, x))
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_player_map\n @map.tiles[@location.first][location.second].seen = true\n #corners\n @map.tiles[@location.first + 1][@location.second - 1].seen = true\n @map.tiles[@location.first - 1][@location.second - 1].seen = true\n @map.tiles[@location.first + 1][@location.second + 1].seen = true\n ... | [
"0.74244654",
"0.67985487",
"0.6310106",
"0.6039057",
"0.5997607",
"0.5917731",
"0.5696204",
"0.5630758",
"0.55744594",
"0.55705756",
"0.5569027",
"0.5552337",
"0.5541701",
"0.54226077",
"0.5404282",
"0.5378507",
"0.5373933",
"0.53683406",
"0.5340139",
"0.53180796",
"0.519530... | 0.6793228 | 2 |
How the Player behaves after winning a battle. | def handle_victory(entity)
type("You defeated the #{entity.name}!\n")
super(entity)
print "\n"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def player_win\n @player.won_bet\n puts \"You have #{@player.chips_remaining} remaining\"\n end",
"def win\n\t\tputs \"Player #{@myIndex} made a correct accusation and has won the game!\"\n\tend",
"def win_message\n puts \"Player #{@id.to_s} (#{@piece}) wins!\"\n end",
"def battle_outcome()\n ... | [
"0.8044219",
"0.7509282",
"0.7461444",
"0.7375538",
"0.7283133",
"0.72822636",
"0.7110048",
"0.709128",
"0.708576",
"0.7047893",
"0.7002596",
"0.6989944",
"0.6984924",
"0.69747096",
"0.6942723",
"0.69220406",
"0.69206995",
"0.6904667",
"0.69037956",
"0.68941754",
"0.68941754"... | 0.0 | -1 |
The treasure given by a Player after losing a battle. | def sample_treasures
nil
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def treasure_drop(enemy)\n if rand(100) < enemy.treasure_prob\n treasure = $data_items[enemy.item_id] if enemy.item_id > 0\n treasure = $data_weapons[enemy.weapon_id] if enemy.weapon_id > 0\n treasure = $data_armors[enemy.armor_id] if enemy.armor_id > 0\n end\n return treasure\n end",
"d... | [
"0.7148631",
"0.71128994",
"0.7036147",
"0.6561897",
"0.6464999",
"0.63113695",
"0.6297646",
"0.6283097",
"0.62032",
"0.61390823",
"0.6107691",
"0.60848916",
"0.60777104",
"0.60464716",
"0.6026727",
"0.6025658",
"0.60153216",
"0.60074407",
"0.5976005",
"0.59339404",
"0.588605... | 0.0 | -1 |
Returns the gold given to a victorious Entity after losing a battle and deducts the figure from the Player's total as necessary | def sample_gold
gold_lost = 0
# Reduce gold if the player has any.
if @gold.positive?
type("Looks like you lost some gold...\n\n")
gold_lost = @gold/2
@gold -= gold_lost
end
gold_lost
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gain_gold\n if $game_troop.gold_total > 0\n rate = Grade.rate(:gold)\n gold = $game_troop.gold_total\n gold = gold * rate / 100\n $game_party.gain_gold(gold)\n else\n gold = 0\n end\n return gold\n end",
"def lose_gold(n)\n gain_gold(-n)\n end",
"def gold_result(en... | [
"0.73759586",
"0.7155349",
"0.7060013",
"0.69382966",
"0.68649083",
"0.6833854",
"0.6819328",
"0.6809912",
"0.66842455",
"0.66752476",
"0.662677",
"0.6573059",
"0.6558426",
"0.6470538",
"0.64487606",
"0.6442957",
"0.64313215",
"0.641958",
"0.6368014",
"0.6317911",
"0.63106894... | 0.7261822 | 1 |
attr_reader :lots attr_writer :otu_id | def initialize(options = {})
opt = {
:otu_id => nil,
:include_specimen_identifiers => :most_recent, # :most_recent, :all, :first
:include_distributions => false, # true might not work now
:include_lots => false, # true might not work now
:include_specimens => true
}.m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_lot\n @lot = Lot.find(params[:id])\n end",
"def set_lot\n @lot = Lot.find(params[:id])\n end",
"def set_lot\n @lot = Lot.find(params[:id] || params[:lot_id])\n end",
"def lot_name\n lot.name\n end",
"def set_eventslot\n @eventslot = Eventslot.find(params[:id])\n ... | [
"0.63560444",
"0.63560444",
"0.62873876",
"0.6133977",
"0.6111231",
"0.5638261",
"0.55661833",
"0.5538123",
"0.553616",
"0.553616",
"0.55190825",
"0.55190825",
"0.54840636",
"0.5478688",
"0.5395919",
"0.53915995",
"0.53821784",
"0.53453",
"0.5340263",
"0.52712417",
"0.5259721... | 0.0 | -1 |
pass an array of specimens | def sex_str(specimens)
v = {}
specimens.each do |s|
v[s.sex] = 0 if !v[s.sex]
v[s.sex] += 1
end
sx = []
v.keys.sort.each do |k|
sx << (v[k] == 1 ? "1 #{k}" : "#{v[k]} #{k}s")
end
sx.join(", ")
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect_specimens(operations:)\n operations.map { |op| op.input_array(SPECIMEN).map(&:item) }.flatten\n end",
"def project_spec_arrays\n [:controller_specs, :model_specs, :view_specs]\n end",
"def spec( *args )\n if args.length == 1\n # Array of 4*Coords in Array.\... | [
"0.62259907",
"0.6098829",
"0.5974337",
"0.5709445",
"0.5631295",
"0.54762113",
"0.5451019",
"0.54435164",
"0.54424405",
"0.5440108",
"0.54169065",
"0.54015744",
"0.5388878",
"0.5348063",
"0.5329697",
"0.5322659",
"0.5314729",
"0.5311235",
"0.5230368",
"0.5213647",
"0.5213647... | 0.0 | -1 |
pass an array of specimens | def inst_str(specimens)
is = []
v = {}
v["unknown"] = []
specimens.each do |s|
if !s.repository.blank? && !s.repository.coden.blank?
if v[s.repository.coden].nil?
v[s.repository.coden] = [s]
else
v[s.repository.coden] << s
end
else
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect_specimens(operations:)\n operations.map { |op| op.input_array(SPECIMEN).map(&:item) }.flatten\n end",
"def project_spec_arrays\n [:controller_specs, :model_specs, :view_specs]\n end",
"def spec( *args )\n if args.length == 1\n # Array of 4*Coords in Array.\... | [
"0.62259907",
"0.6098829",
"0.5974337",
"0.5709445",
"0.5631295",
"0.54762113",
"0.5451019",
"0.54435164",
"0.54424405",
"0.5440108",
"0.54169065",
"0.54015744",
"0.5388878",
"0.5348063",
"0.5329697",
"0.5322659",
"0.5314729",
"0.5311235",
"0.5230368",
"0.5213647",
"0.5213647... | 0.0 | -1 |
pass an array of specimens | def country_str(specimens)
v = {}
v["country not specified"] = []
specimens.each do |s|
if !s.ce.blank? && !s.ce.geog.blank? && !s.ce.geog.country.blank? && !s.ce.geog.country.name.blank?
if v[s.ce.geog.country.name].nil?
v[s.ce.geog.country.name] = [s]
else
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect_specimens(operations:)\n operations.map { |op| op.input_array(SPECIMEN).map(&:item) }.flatten\n end",
"def project_spec_arrays\n [:controller_specs, :model_specs, :view_specs]\n end",
"def spec( *args )\n if args.length == 1\n # Array of 4*Coords in Array.\... | [
"0.62259907",
"0.6098829",
"0.5974337",
"0.5709445",
"0.5631295",
"0.54762113",
"0.5451019",
"0.54435164",
"0.54424405",
"0.5440108",
"0.54169065",
"0.54015744",
"0.5388878",
"0.5348063",
"0.5329697",
"0.5322659",
"0.5314729",
"0.5311235",
"0.5230368",
"0.5213647",
"0.5213647... | 0.0 | -1 |
The methods below this are summaries render a quick display (should move to a helper likely) | def display_quick
s = ''
for i in @me.keys
s << " <b>#{i}.</b><br/>" # country
for j in @me[i].keys
s << " <b>#{j}:</b><br/>" if not j == 'unknown' # state
for k in @me[i][j].keys
s << " #{k}<br/>" if not k == 'unknown' # county
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def summary\n #render unless @output\n @summary\n end",
"def render_summary\n summary = nil\n\n end",
"def summary\n \n end",
"def summary\n end",
"def summary\n end",
"def summary; end",
"def summary; end",
"def summary; end",
"def summary; end",
"def summary\n # TO... | [
"0.74183255",
"0.7262107",
"0.724728",
"0.71588504",
"0.71588504",
"0.7126353",
"0.7126353",
"0.7126353",
"0.7126353",
"0.7065552",
"0.6954688",
"0.68671477",
"0.68125504",
"0.6693552",
"0.6680704",
"0.66309476",
"0.6582658",
"0.6552832",
"0.6523691",
"0.6518315",
"0.6491239"... | 0.63020146 | 46 |
crude and somewhat duplicated could be simplified for sure | def _from_distributions(otu)
ds = otu.distributions
sex = 'unknown'
rep = 'unknown'
if not ds == nil
for d in ds
if d.geog_id
country = d.geog.country ? d.geog.country.name : 'unknown'
state = d.geog.state ? d.geog.state.name : 'unknown'
cou... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def private; end",
"def probers; end",
"def schubert; end",
"def anchored; end",
"def suivre; end",
"def stderrs; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def formation; end",
"def offences_by; end",
"def transformations; end",
"def operations; en... | [
"0.67515683",
"0.6312525",
"0.6046015",
"0.6020571",
"0.59406114",
"0.58216065",
"0.5820206",
"0.5820206",
"0.5820206",
"0.5820206",
"0.5813013",
"0.5775777",
"0.5754169",
"0.5612189",
"0.5612189",
"0.5576442",
"0.5554098",
"0.5552385",
"0.5551547",
"0.5529452",
"0.5524351",
... | 0.0 | -1 |
GET /test_questions/1 GET /test_questions/1.json | def show
@test_question = TestQuestion.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.json { render :json => @test_question }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n render json: @test_module.test_questions, status: :ok\n end",
"def questions\n self.class.get(\"/2.2/questions\", @options)\n end",
"def get_question_list\n json= RestClient.get(\"http://localhost:3000/questions\")\n JSON.parse(json)\n end",
"def index\n @questions = Quest... | [
"0.76273316",
"0.7617988",
"0.7499508",
"0.7131678",
"0.7084854",
"0.70559084",
"0.7049141",
"0.7017962",
"0.6995291",
"0.6921943",
"0.6921117",
"0.68634236",
"0.6856893",
"0.6797967",
"0.67955124",
"0.67807794",
"0.6770636",
"0.67601764",
"0.675877",
"0.675877",
"0.675877",
... | 0.7409299 | 3 |
GET /test_questions/new GET /test_questions/new.json | def new
@test_question = TestQuestion.new
respond_to do |format|
format.html # new.html.erb
format.json { render :json => @test_question }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n #@question = Question.new\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @question }\n end\n end",
"def new\n @question = Question.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @question }... | [
"0.7850332",
"0.7842054",
"0.7842054",
"0.7842054",
"0.7842054",
"0.7842054",
"0.7769053",
"0.7741807",
"0.76394236",
"0.75785047",
"0.7525696",
"0.74207133",
"0.74169517",
"0.74103963",
"0.7407483",
"0.7403773",
"0.73939776",
"0.73933125",
"0.7390224",
"0.7376302",
"0.737326... | 0.7969413 | 0 |
POST /test_questions POST /test_questions.json | def create
@test_question = TestQuestion.new(params[:test_question])
respond_to do |format|
if @test_question.save
format.html { redirect_to @test_question, :notice => 'Test question was successfully created.' }
format.json { render :json => @test_question, :status => :created, :location ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @test_question = TestQuestion.new(test_question_params)\n\n respond_to do |format|\n if @test_question.save\n format.html { redirect_to @test_question, notice: 'Test question was successfully created.' }\n format.json { render :show, status: :created, location: @test_question ... | [
"0.71973485",
"0.71973485",
"0.7070897",
"0.6947893",
"0.6812038",
"0.6792296",
"0.67156166",
"0.6702249",
"0.6676173",
"0.66741323",
"0.6644101",
"0.6619836",
"0.66078454",
"0.6598531",
"0.6592832",
"0.6485802",
"0.6456139",
"0.64504063",
"0.6449363",
"0.64361995",
"0.637914... | 0.7289749 | 0 |
PUT /test_questions/1 PUT /test_questions/1.json | def update
@test_question = TestQuestion.find(params[:id])
respond_to do |format|
if @test_question.update_attributes(params[:test_question])
format.html { redirect_to @test_question, :notice => 'Test question was successfully updated.' }
format.json { head :ok }
else
format... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @survey = Survey.find(params[:id])\n json = params[:survey]\n json[:questions] = JSON.parse(json[:questions])\n json[:questions].each_with_index do |question, idx|\n json[:questions][idx]['id'] = idx + 1\n end\n\n respond_to do |format|\n if @survey.update_attributes(json)\... | [
"0.6997375",
"0.6963279",
"0.6862295",
"0.6816271",
"0.6780306",
"0.6747774",
"0.6659595",
"0.6625654",
"0.66036695",
"0.65941435",
"0.65813667",
"0.65140575",
"0.6468147",
"0.6456749",
"0.64493847",
"0.6426765",
"0.6426765",
"0.6426765",
"0.6426765",
"0.6426765",
"0.64069027... | 0.7103229 | 0 |
DELETE /test_questions/1 DELETE /test_questions/1.json | def destroy
@test_question = TestQuestion.find(params[:id])
@test_question.destroy
respond_to do |format|
format.html { redirect_to test_questions_url }
format.json { head :ok }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete\n question = QuestionTest.where(test_id: params[:test_id], question_id: params[:id])\n if question.delete_all\n return render json: {message: 'Question was removed succesfully.', error: false}\n else\n return render json: {message: 'Error: Something went wrong. Question was ... | [
"0.77042663",
"0.75446856",
"0.75446856",
"0.75303197",
"0.7495366",
"0.73791075",
"0.734512",
"0.734512",
"0.734512",
"0.734512",
"0.734512",
"0.734512",
"0.73442084",
"0.7342919",
"0.73042595",
"0.73042595",
"0.7303724",
"0.7284187",
"0.7283592",
"0.7282965",
"0.7282965",
... | 0.78112733 | 0 |
First line defines the mathod 'cheese_and_crackers' with the arguments (cheese_count, boxes_of_crackers) | def cheese_and_crackers(cheese_count, boxes_of_crackers)
#prints "You have X cheeses!" The number would be the first number put inside of the method variables.
puts "You have #{cheese_count} cheeses!"
#prints "You have X boxes of crackers!"
puts "You have #{boxes_of_crackers} boxes of crackers!"
#prints "Man ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cheese_and_crackers(cheese_count, boxes_of_crackers)\n puts \"You have #{cheese_count} cheeses.\"\n puts \"You have #{boxes_of_crackers} boxes of crackers.\"\n puts \"Party on, you fat bastard!\\n\"\nend",
"def cheese_and_crackers(cheese_count, boxes_of_crackers)\n\tputs \"You have #{cheese_count} cheeses... | [
"0.7751951",
"0.76843095",
"0.76841515",
"0.76822186",
"0.7677064",
"0.7654234",
"0.76409215",
"0.76380426",
"0.76228297",
"0.76228297",
"0.76228297",
"0.76228297",
"0.76228297",
"0.76228297",
"0.76228297",
"0.76228297",
"0.76228297",
"0.76228297",
"0.75442857",
"0.7422361",
... | 0.7191251 | 21 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.