query stringlengths 7 9.5k | document stringlengths 10 1.07M | negatives listlengths 19 19 | metadata dict |
|---|---|---|---|
Private: Checks if the session expiry time has passed Returns a Boolean | def session_valid?
@session_expiry_time > Time.now if @session_expiry_time
end | [
"def session_valid?\n @session_expiry_time > Time.now if @session_expiry_time\n end",
"def session_expired?\n ! (Time.now < session[:expire_at])\n end",
"def session_expired?\n if session[:current_user]\n @validity_time ||= 600\n session[:session_start_time] + @validity_time.t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create the ingredients for the recipe recipe_id: id of the recipe ingredients: list of ingredients for a recipe | def create_ingredient(recipe_id, ingredients)
destroy_ingredients = RecipeIngredient.where(recipe_id: recipe_id)
if !destroy_ingredients.blank?
destroy_ingredients.delete_all
end
ingredients.each do |recipe_ingredient|
ingredient = RecipeIngredient.new
ingredient.recipe_id = recipe_id
... | [
"def create_ingredients(recipe, count: 2)\n (1..count).map do |i|\n create :ingredient, recipe_id: recipe.id\n end\n end",
"def add_ingredients(ingredients)\n ingredients.each do |item|\n RecipeIngredient.new(self, item)\n end\n end",
"def create\n\n user = UserSession.user_by_authent... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create the tags for the recipe recipe_id: id of the recipe tags: list of tags for a recipe | def create_tag(recipe_id, tags)
destroy_tags = RecipeTag.where(recipe_id: recipe_id)
if !destroy_tags.blank?
destroy_tags.delete_all
end
tags.each do |recipe_tag|
tag = RecipeTag.new
tag.recipe_id = recipe_id
tag.tag = recipe_tag
tag.save!
end
end | [
"def create_tags(resource_id, tags)\n # Tags need to be created individually in fog\n tags.each do |k, v|\n @compute_provider.tags.create(:resource_id => resource_id,\n :key => k.to_s, :value => v.to_s)\n end\n end",
"def create_new_tags\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Find all recipes matching the parameters recipe_name: name of the recipe recipe_tag: a single tag for a recipe recipe_ingredients: list of ingredients | def get_recipes(recipe_name, recipe_tag, recipe_ingredients)
recipes_ids = Set.new
ingredients_upcase = Set.new
#search by
case
when !recipe_name.blank?
recipes_ids = Recipe.where('UPPER(name) LIKE UPPER(?)', "%#{recipe_name}%").pluck(:id)
when !recipe_tag.blank?
recipes_ids = RecipeTa... | [
"def find_recipes(ingredients)\n system 'clear'\n @recipe_data.each do |recipe|\n recipe.each do |key, value|\n i = 1\n if ingredients.include?(value)\n puts \"ID: #{recipe[:id]}\\nTitle: #{recipe[:title]}\\nDirections: #{recipe[:directions]}... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the role property value. The role property | def role
return @role
end | [
"def getRole\r\n\t\t\t\t\treturn @role\r\n\t\t\t\tend",
"def role\n @role\n end",
"def user_role\n return @user_role\n end",
"def role\n @instance['role']\n end",
"def role\n if !instance_variable_defined?(:@role)\n @role = user.role\n end\n re... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the role property value. The role property | def role=(value)
@role = value
end | [
"def setRole(role)\r\n\t\t\t\t\t@role = role\r\n\t\t\t\tend",
"def role=(new_role)\n @role = new_role\n end",
"def role=(role)\n @params[:acl].update_role(self, role)\n end",
"def set_Role(value)\n set_input(\"Role\", value)\n end",
"def user_role=(value)\n @us... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks if the folder is shared | def shared?
!self.shared_folders.empty?
end | [
"def shared?\n !self.shared_folders.empty?\n end",
"def shared? \n \t!self.shared_folders.empty? \n\tend",
"def shared? \n \t@shared_folder = SharedFolder.find_by_folder_id(self.id)\n \tif @shared_folder.nil?\n \t\tfalse\n \telse\n \t\ttrue\n \tend \n\tend",
"def has_share_access?... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks if the folder is public | def public?
!self.public_folders.empty?
end | [
"def private?\n self.public_folders.empty?\n end",
"def in_public?(path)\n expand(path).start_with?(expand(Global.public_root))\n end",
"def is_public?\n is_public == true && requires_login == false\n end",
"def root_public?\n self.root.public?\n end",
"def public?\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks to see if the folder is private. (not public) | def private?
self.public_folders.empty?
end | [
"def private?\n rights == 'private'\n end",
"def is_private?\n is_public == false\n end",
"def public?\n !self.public_folders.empty?\n end",
"def is_private\n return @is_private\n end",
"def root_private?\n self.root.private?\n end",
"def is_privat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Is the root folder public? | def root_public?
self.root.public?
end | [
"def public?\n !self.public_folders.empty?\n end",
"def in_public?(path)\n expand(path).start_with?(expand(Global.public_root))\n end",
"def root?\n @root_folder\n end",
"def private?\n self.public_folders.empty?\n end",
"def root_private?\n self.root.private?\n end",
"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Is the root folder private? | def root_private?
self.root.private?
end | [
"def root_public?\n self.root.public?\n end",
"def private?\n self.public_folders.empty?\n end",
"def root?\n @root_folder\n end",
"def root?\n \tfolder_id.nil?\n end",
"def public?\n !self.public_folders.empty?\n end",
"def is_root?\n User.is_root?(self)\n end",
"def root?\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gather a list of all the email adresses that the folder is shared with | def to_shared_emails
#shared_to = SharedFolder.select("shared_email").find(:all, :conditions => ["folder_id = ?",id])
email_addresses = Array.new
shared_folders.each do |folder|
email_addresses.push(folder.shared_email)
end
email_addresses
end | [
"def mail_folders\n return @mail_folders\n end",
"def findEmails\n addresses = []\n @dav.find('.',:recursive=>true,:suppress_errors=>true,:filename=>/\\.vcf$/) do | item |\n cards = Vpim::Vcard.decode(item.content)\n\n cards.each do |card|\n if not (card.email.nil?... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a zip file and saves the location and creation time if the zip file location hasn't been saved or the contents of the folder has changed. (needs to be recursive) | def zip
if !FileTest::directory?("/mnt/filebox/assets/zipfile_repository")
Dir::mkdir("/mnt/filebox/assets/zipfile_repository")
end
if self.zipped_file.nil? or !File.file?(self.zipped_file)
logger.info("[ZIP] Creating zipfile for #{self.name}")
self.zipped_file = "/mnt/filebox/assets/zipfi... | [
"def assure_created_zip\n FileCreator::createNewZip(self)\n raise \"No file created\" unless File.exists? zip_path\n end",
"def create_zip!\n ensure_zip_directory!\n Dir.chdir(work_dir.to_s) do\n combined, status = Open3.capture2e(zip_command)\n raise \"zipmaker failure #{combined}\" unless... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Helper for the zip method which creates the zip stream and calls the zip decender | def _zip
Zip::ZipFile.open(self.zipped_file, Zip::ZipFile::CREATE) do |z|
self._zip_decender(z,self,nil)
end
end | [
"def zip\n @zip\n end",
"def zipped_stream(entry)\n if Zlib::ZLIB_VERSION < '1.2.1'\n zis = Zlib::GzipReader.new entry\n dis = zis.read\n is = StringIO.new(dis)\n else\n is = Zlib::GzipReader.new entry\n end\n ensure\n zis.finish if zis\n end",
"def expo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds folder assets to the zip object and decends into the subfolders recursively adding their assets as well. | def _zip_decender(zipstream, folder, path)
if path.nil?
path = folder.name
else
path = path + "/" + folder.name
end
zipstream.dir.mkdir(path)
folder.assets.each do |a|
logger.info("[ZIP] Adding #{a.file_name} in #{a.uploaded_file.path}")
zipstream.add("#{path}/#{a.file_n... | [
"def add_files(zip)\n ZipFileGenerator.new(@manifest.base_dir, zip).write\n end",
"def run\n assets.each do |asset|\n next if ::File.directory?(asset)\n\n compress(asset)\n checksum(asset)\n end\n\n generate_manifest\n end",
"def recursively_deflate_direc... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /invoicestatuses GET /invoicestatuses.json | def index
@invoicestatuses = Invoicestatus.all
end | [
"def index\n @invoicelines = Invoiceline.all\n end",
"def show\n @invoiceline = Invoiceline.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @invoiceline }\n end\n end",
"def index\n @intakeoutputs = Intakeoutput.all\n render j... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /people_terms POST /people_terms.json | def create
@people_term = PeopleTerm.new(people_term_params)
respond_to do |format|
if @people_term.save
format.html { redirect_to @people_term, notice: 'People term was successfully created.' }
format.json { render :show, status: :created, location: @people_term }
else
form... | [
"def add_terms(params)\n send_get \"add_terms\", params\n end",
"def create\n @privacy_term = PrivacyTerm.new(params[:privacy_term])\n\n respond_to do |format|\n if @privacy_term.save\n format.html { redirect_to @privacy_term, notice: 'Privacy term was successfully created.' }\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /people_terms/1 PATCH/PUT /people_terms/1.json | def update
respond_to do |format|
if @people_term.update(people_term_params)
format.html { redirect_to @people_term, notice: 'People term was successfully updated.' }
format.json { render :show, status: :ok, location: @people_term }
else
format.html { render :edit }
forma... | [
"def update_term(t_id, term_info)\n term_info = {\"term\" => term_info}\n request = API_URL + \"terms/#{t_id}\"\n @response = RestClient.patch request, term_info#\n @parsed_response = JSON.parse(@response)\n log_mutant(\"updated\")\n return\nend",
"def update\n @terms_of_use = TermsOfUse.find(params[:id]... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /people_terms/1 DELETE /people_terms/1.json | def destroy
@people_term.destroy
respond_to do |format|
format.html { redirect_to people_terms_url, notice: 'People term was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def delete_term(t_id)\n\n request = API_URL + \"terms/#{t_id}\"\n @response = RestClient.delete request\n log_mutant(\"deleted\")\n return\nend",
"def destroy\n @go_term = GoTerm.find(params[:id])\n @go_term.destroy\n\n respond_to do |format|\n format.html { redirect_to go_terms_url }\n fo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /card_pages GET /card_pages.json | def index
@card_pages = CardPage.all
end | [
"def cards(page)\n self.options[:query][:page] = page || 1\n http_response = self.class.get(\"/v1/cards\", @options)\n json_response = JSON.parse(http_response.body)\n cards = []\n json_response[\"cards\"].each do |json_card|\n cards << Card.new(json_card)\n end\n cards\n end",
"def ind... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /card_pages POST /card_pages.json | def create
@card_page = CardPage.new(card_page_params)
respond_to do |format|
if @card_page.save
format.html { redirect_to @card_page, notice: 'Card page was successfully created.' }
format.json { render action: 'show', status: :created, location: @card_page }
else
format.ht... | [
"def create\n @cardpage = Cardpage.new(cardpage_params)\n\n respond_to do |format|\n if @cardpage.save\n format.html { redirect_to @cardpage, notice: 'Cardpage was successfully created.' }\n format.json { render :show, status: :created, location: @cardpage }\n else\n format.html... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /card_pages/1 PATCH/PUT /card_pages/1.json | def update
respond_to do |format|
if @card_page.update(card_page_params)
format.html { redirect_to @card_page, notice: 'Card page was successfully updated.' }
format.json { head :no_content }
else
format.html { render action: 'edit' }
format.json { render json: @card_page... | [
"def update\n respond_to do |format|\n if @cardpage.update(cardpage_params)\n format.html { redirect_to @cardpage, notice: 'Cardpage was successfully updated.' }\n format.json { render :show, status: :ok, location: @cardpage }\n else\n format.html { render :edit }\n format.j... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /card_pages/1 DELETE /card_pages/1.json | def destroy
@card_page.destroy
respond_to do |format|
format.html { redirect_to card_pages_url }
format.json { head :no_content }
end
end | [
"def destroy\n @cardpage.destroy\n respond_to do |format|\n format.html { redirect_to cardpages_url, notice: 'Cardpage was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @api_v1_card.destroy\n respond_to do |format|\n format.html { head :n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /field_definitions GET /field_definitions.json | def index
if params[:step_definition_id]
step_definition = StepDefinition.find(params[:step_definition_id])
if step_definition != nil
@field_definitions = step_definition.field_definitions
else
@field_definitions = []
end
else
@field_definitions = FieldDefinition.... | [
"def field_definitions\n @field_definitions ||= each_field_with_object({}) { |field_name, field_definition, results|\n results[field_name] = field_definition.merge(results[field_name])\n }\n end",
"def field_definition_for fieldId\n end",
"def create\n field_def = fields_definitions.build(create... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /field_definitions POST /field_definitions.json | def create
@field_definition = FieldDefinition.new(field_definition_params)
respond_to do |format|
if @field_definition.save
format.html { redirect_to @field_definition, notice: 'Field definition was successfully created.' }
format.json { render :show, status: :created, location: @field_d... | [
"def create\n field_def = fields_definitions.build(create_params)\n\n field_def.save\n\n respond_with(field_def)\n end",
"def create\n\n step_definition_attributes = step_definition_params\n field_definitions_attributes = step_definition_attributes.delete(\"field_definitions\")\n\n @step_defini... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /field_definitions/1 PATCH/PUT /field_definitions/1.json | def update
respond_to do |format|
if @field_definition.update(field_definition_params)
format.html { redirect_to @field_definition, notice: 'Field definition was successfully updated.' }
format.json { render :show, status: :ok, location: @field_definition }
else
format.html { ren... | [
"def update\n fields_definition.update(update_params)\n respond_with(fields_definition)\n end",
"def update\n\n step_definition_attributes = step_definition_params\n field_definitions_attributes = step_definition_attributes.delete(\"field_definitions\")\n\n FieldDefinition.updateFieldDefinitions(f... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /field_definitions/1 DELETE /field_definitions/1.json | def destroy
@field_definition.destroy
respond_to do |format|
format.html { redirect_to field_definitions_url, notice: 'Field definition was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n fields_definition.destroy\n respond_with(fields_definition)\n end",
"def destroy\n @api_v1_field.destroy\n respond_to do |format|\n format.html { redirect_to api_v1_fields_url, notice: 'Field was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
=begin Create one time token to use API. | def create_token
return api_call('request-token',{"apiKey"=> @@_api_key });
end | [
"def create_api_token(); self.api_token = SecureRandom.urlsafe_base64(180); end",
"def create_token\n # Generate a random endpoint for the customer\n endpoint = (0...13).map { ('a'..'z').to_a[rand(26)] }.join\n @token = generate_token endpoint\n end",
"def createToken\n parameters = {... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
=begin Convert an array to xml string. | def array_to_xml(hash, xml)
require "active_support/core_ext"
return hash.to_xml(:root => 'queue')
end | [
"def convert_to_xml(array)\n element = REXML::Element.new(\"list\")\n array.each do |item|\n list_element = REXML::Element.new(\"item\")\n list_element.add_text(item)\n element.add_element(list_element)\n end\n element\n end",
"def to_ArrayedXml()\n # head part\n axml = [[nil, Xm... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
=begin Convert an xml string to array. | def xml_to_array(xml_string)
return Hash.from_xml(xml_string)
end | [
"def string_to_array(xml_doc)\n responses = []\n xml_doc.root.each_element do |element|\n response_type = element.name\n responses << element.text\n end\n\n responses\n end",
"def array_from_xml(xml, opts=OPTS)\n node = Nokogiri::XML(xml).children.first\n unless node \n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns or yields parent breadcrumb (secondtolast in the trail) if it is present. () | def parent_breadcrumb(options = {}, &block)
if block_given?
gretel_renderer.yield_parent_breadcrumb(options, &block)
else
gretel_renderer.parent_breadcrumb(options)
end
end | [
"def parent_breadcrumb(options = {})\n render(options)[-2]\n end",
"def yield_parent_breadcrumb(options = {})\n if parent = parent_breadcrumb(options)\n yield parent\n end\n end",
"def drop_previous_breadcrumb_if; end",
"def prior_sibling\n if parent\n first_child? ? ni... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Write a recursive method that returns the sum of the first n even numbers recursively. Assume n > 0. | def first_even_numbers_sum(n)
return 2 if n == 1
2 * n + first_even_numbers_sum(n-1)
end | [
"def first_even_numbers_sum(n)\n return 2 if n == 1\n first_even_numbers_sum(n-1) + (n*2)\n end",
"def first_even_numbers_sum(n)\n return 2 if n == 1\n 2 * n + first_even_numbers_sum(n-1)\n end",
"def first_even_numbers_sum(n)\n return 0 if n <= 0\n 2*n + first_even_numbers_sum(n-1)\n end",... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /abooks GET /abooks.json | def index
@abooks = Abook.all
end | [
"def index\n render json: user_shelf.books\n end",
"def index\n @books = get_books()\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @books }\n end\n end",
"def index\n @books = Book.get_avaible_books\n end",
"def index\n @books = Book.all\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /abooks POST /abooks.json | def create
@abook = Abook.new(abook_params)
respond_to do |format|
if @abook.save
format.html { redirect_to @abook, notice: 'Abook was successfully created.' }
format.json { render :show, status: :created, location: @abook }
else
format.html { render :new }
format.js... | [
"def create\n @abook = Abook.new(abook_params)\n\n respond_to do |format|\n if @abook.save\n format.html { redirect_to @abook, notice: 'Abook was successfully created.' }\n format.json { render action: 'show', status: :created, location: @abook }\n else\n format.html { render ac... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /abooks/1 PATCH/PUT /abooks/1.json | def update
respond_to do |format|
if @abook.update(abook_params)
format.html { redirect_to @abook, notice: 'Abook was successfully updated.' }
format.json { render :show, status: :ok, location: @abook }
else
format.html { render :edit }
format.json { render json: @abook.e... | [
"def update\n respond_to do |format|\n if @abook.update(abook_params)\n format.html { redirect_to @abook, notice: 'Abook was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @abook.errors,... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /abooks/1 DELETE /abooks/1.json | def destroy
@abook.destroy
respond_to do |format|
format.html { redirect_to abooks_url, notice: 'Abook was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n @abook.destroy\n respond_to do |format|\n format.html { redirect_to abooks_url }\n format.json { head :no_content }\n end\n end",
"def delete_aos_version(args = {}) \n delete(\"/aosversions.json/#{args[:aosVersionId]}\", args)\nend",
"def destroy\n @api_book.destroy\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
author_name knows the name of its author returns nil if the post does not have an author | def author_name
if self.author
self.author.name
else
nil
end
end | [
"def author_name\n post.author = self\n author_name if author\n end",
"def author\n @title_pages.each { |tp| tp.author and return tp.author }\n nil\n end",
"def author_name\n return \"\" if contents.empty?\n contents.first.author_name\n end",
"def author_name\n if is_news?\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /requests/devolutions/products/details/1 GET /requests/devolutions/products/details/1.json | def show
@requests_devolutions_products_detail = Requests::Devolutions::Products::Detail.find(params[:id])
respond_to do |format|
format.html
end
end | [
"def show\n @requests_transferences_products_detail = Requests::Transferences::Products::Detail.find(params[:id])\n respond_to do |format|\n format.html\n end\n end",
"def show\n @product_detail = ProductDetail.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /requests/devolutions/products/details/new GET /requests/devolutions/products/details/new.json | def new
@requests_devolutions_products_detail = Requests::Devolutions::Products::Detail.new
respond_to do |format|
end
end | [
"def new\n @product = Product.new\n\n render json: @product\n end",
"def new\n @product_detail = ProductDetail.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @product_detail}\n end\n end",
"def new\n get_product\n @product_detail = @prod... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generate the next round of paths | def next_paths
Operations.list.map do |operation|
new_value = Operations.send(operation, @current_value)
operation_history = @operation_history + [operation]
Path.new(new_value, @target_value, operation_history: operation_history)
end
end | [
"def next\n next_paths = @paths.flat_map(&:next_paths)\n Generation.new(next_paths, generations_count: @generations_count + 1)\n end",
"def greedy_calc_path\n # Start from the target\n endpoint = grid.target\n # And the cell it came from\n next_endpoint = greedy.came_from[endpoint]\n while e... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /student_categories GET /student_categories.json | def index
# @student_categories = StudentCategory.all
respond_to do |format|
format.html # index.html.erb
format.json { render json: @student_categories }
end
end | [
"def show\n # @student_category = StudentCategory.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @student_category }\n end\n end",
"def categories\n render json: @user.categories_accessible_by(current_user).to_json\n end",
"def cate... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /student_categories/1 GET /student_categories/1.json | def show
# @student_category = StudentCategory.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.json { render json: @student_category }
end
end | [
"def index\n # @student_categories = StudentCategory.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @student_categories }\n end\n end",
"def new\n # @student_category = StudentCategory.new\n\n respond_to do |format|\n format.html # new.html.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /student_categories/new GET /student_categories/new.json | def new
# @student_category = StudentCategory.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @student_category }
end
end | [
"def new\n @newscategory = Newscategory.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @newscategory }\n end\n end",
"def create\n # @student_category = StudentCategory.new(params[:student_category])\n\n respond_to do |format|\n if @student_c... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /student_categories POST /student_categories.json | def create
# @student_category = StudentCategory.new(params[:student_category])
respond_to do |format|
if @student_category.save
format.html { redirect_to @student_category, notice: 'Student category was successfully created.' }
format.json { render json: @student_category, status: :create... | [
"def index\n # @student_categories = StudentCategory.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @student_categories }\n end\n end",
"def create\n @student_app_cat_217127274 = StudentAppCat217127274.new(student_app_cat_217127274_params)\n\n r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /student_categories/1 PUT /student_categories/1.json | def update
# @student_category = StudentCategory.find(params[:id])
respond_to do |format|
if @student_category.update_attributes(params[:student_category])
format.html { redirect_to @student_category, notice: 'Student category was successfully updated.' }
format.json { head :ok }
els... | [
"def update_categories(categories, options = {} )\n options.merge!(:docid => self.docid, :categories => categories)\n resp = @conn.put do |req|\n req.url \"categories\"\n req.body = options.to_json\n end\n\n resp.status \n end",
"def update\n @studentcourse = ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /student_categories/1 DELETE /student_categories/1.json | def destroy
# @student_category = StudentCategory.find(params[:id])
@student_category.destroy
respond_to do |format|
format.html { redirect_to student_categories_url }
format.json { head :ok }
end
end | [
"def destroy\n @student.delete\n respond_to do |format|\n format.html { redirect_to students_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @student_type.destroy\n\n head :no_content\n end",
"def destroy\n @studentset = Studentset.find(params[:id])\n @stud... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /cake_flavors GET /cake_flavors.json | def index
@cake_flavors = CakeFlavor.all
end | [
"def flavors()\n return get_request(address(\"/flavors/detail\"), @token)\t\n end",
"def flavors\n actuator = Actuator.find(params[:id])\n respond_to do |format|\n format.html { render json: actuator.flavors}\n format.json { render json: actuator.flavors}\n end\n end",
"def flavors\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /cake_flavors POST /cake_flavors.json | def create
@cake_flavor = CakeFlavor.new(cake_flavor_params)
respond_to do |format|
if @cake_flavor.save
format.html { redirect_to @cake_flavor, notice: 'Cake flavor was successfully created.' }
format.json { render :show, status: :created, location: @cake_flavor }
else
form... | [
"def create\n @flavor = Flavor.new(flavor_params)\n\n respond_to do |format|\n if @flavor.save\n format.html { redirect_to @flavor, notice: 'Flavor was successfully created.' }\n format.json { render :show, status: :created, location: @flavor }\n else\n format.html { render :new... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /cake_flavors/1 PATCH/PUT /cake_flavors/1.json | def update
respond_to do |format|
if @cake_flavor.update(cake_flavor_params)
format.html { redirect_to @cake_flavor, notice: 'Cake flavor was successfully updated.' }
format.json { render :show, status: :ok, location: @cake_flavor }
else
format.html { render :edit }
forma... | [
"def update\n @flavor = Flavor.find(params[:id])\n\n respond_to do |format|\n if @flavor.update_attributes(params[:flavor])\n format.html { redirect_to @flavor, :notice => 'Flavor was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render :action => \"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /cake_flavors/1 DELETE /cake_flavors/1.json | def destroy
@cake_flavor.destroy
respond_to do |format|
format.html { redirect_to cake_flavors_url, notice: 'Cake flavor was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n compute.delete_flavor(params[:id])\n \n\n respond_to do |format|\n format.html { redirect_to flavors_path }\n format.json { head :ok }\n end\n end",
"def destroy\n @flavor = Flavor.find(params[:id])\n @flavor.destroy\n\n respond_to do |format|\n format.html { re... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /product_classifies POST /product_classifies.json | def create
@product_classify = ProductClassify.new(product_classify_params)
respond_to do |format|
if @product_classify.save
format.html { redirect_to :product_classifies, notice: '产品分类添加成功。' }
format.json { render :show, status: :created, location: @product_classify }
else
... | [
"def create\n @classify = Classify.new(classify_params)\n\n respond_to do |format|\n if @classify.save\n format.html { redirect_to admin_classifies_path(@classify), notice: 'Classify was successfully created.' }\n\n else\n format.html { render :new }\n\n end\n end\n end",
"d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /product_classifies/1 PATCH/PUT /product_classifies/1.json | def update
respond_to do |format|
if @product_classify.update(product_classify_params)
format.html { redirect_to :product_classifies, notice: '产品分类修改成功。' }
format.json { render :show, status: :ok, location: @product_classify }
else
format.html { render :edit }
format.json... | [
"def update\n @classified = Classified.find(params[:id])\n\n respond_to do |format|\n if @classified.update_attributes(params[:classified])\n format.html { redirect_to @classified, notice: 'Classified was successfully updated.' }\n format.json { head :no_content }\n else\n forma... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /product_classifies/1 DELETE /product_classifies/1.json | def destroy
@product_classify.destroy
respond_to do |format|
format.html { redirect_to product_classifies_url, notice: '产品分类删除成功。' }
format.json { head :no_content }
end
end | [
"def destroy\n @item_classification.destroy\n respond_to do |format|\n format.html { redirect_to item_classifications_url, notice: 'Classificação destruída com sucesso.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @productclass = Productclass.find(params[:id])\n @pr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
function for get the data from ebi | def obtain_data_from_ebi(gene)
address = URI("http://www.ebi.ac.uk/Tools/dbfetch/dbfetch?db=ensemblgenomesgene&format=embl&id=#{gene}")
response = Net::HTTP.get_response(address) # use the Net::HTTP object "get_response" method
record = response.body
entry = Bio::EMBL.new(record)
ac_seq= en... | [
"def get_data\n\t\t@data\n\tend",
"def getExtendedData( oid )\n\n # parameter TypeCheck\n #BIMserverAPI::TypeCheck::Long( oid )\n\n # BIMserver request\n request( { oid: oid } )\n end",
"def get_data()\n @base\n end",
"def data\n fetch_data_by_key(:data)\n end",
"def b_dat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
function for creating new features to the EnsEMBL Sequence object | def create_features_ensembl_seq_obj(bioseq,targets)
targets.each do |key,value|
f1 = Bio::Feature.new("target_CTTCTT","#{key[0]}..#{key[1]}")
#im no sure if it is a interior coding exon
f1.append(Bio::Feature::Qualifier.new('interior coding exon', "#{value[0]}"))
f1.append(Bio:... | [
"def add_features(biosequence, gene_id, plus_target_positions, minus_target_positions)\n chr_num = biosequence.definition.match(/chromosome\\s(\\d)/)[1]\n chr_init_pos = biosequence.definition.match(/(\\d+)\\.\\.\\d+/)[1].to_i \n for target in plus_target_positions\n feature = Bio::Feature.new(\"targeting_vec... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
function for writing in the txt and gff files | def write_gff_files(gene,fo,f1,f2)
bioseq_seq, chr_id, chr_cord = obtain_data_from_ebi(gene)
target_hash = obtain_target_from_seq(bioseq_seq)
create_features_ensembl_seq_obj(bioseq_seq,target_hash)
chr_target_hash=change_cord(target_hash,chr_cord)
if target_hash.empty?
f1.puts "#{gene... | [
"def open_new_file_to_write (number)\noutfile = \"\"\n\toutfile = File.new(\"Blastn_to_gff3-#{number}.gff\", \"w\")\n\toutfile.puts \"##gff-version 3\"\n\toutfile.puts \"##mRNA row have 'Genelength' attribute presenting length of RNA-seq contig and exon rows have 'Target' attibute depicting start and stop mRNA matc... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Is the animal a firefox? | def firefox?
if @type.downcase == "firefox"
return true
else
return false
end
end | [
"def is_firefox?\n begin\n find_window(\"MozillaWindowClass\")#MozillaUIWindowClassname\n return true if @main_window >0\n rescue =>e\n raise \"not exit firefox #{e} only support on windows OS\"\n return false\n end\n end",
"def firefox_browser?\n user_agent = Us... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Direct access to right_cloud_stack gem Useful for debugging in irb | def handle
@cloud_stack
end | [
"def get_stacks_log\n _get_log('stacks')\n end",
"def execute!\n name_required!\n stack_name = name_args.last\n stack = provider.stack(stack_name)\n ui.info \"Stack inspection #{ui.color(stack_name, :bold)}:\"\n outputs = api_action!(:api_stack => stack) do\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
=== Returns String:: newly created volume id | def volume_create(name)
@log.info "Creating volume #{name} from offering id #{DISK_OFFERING}..."
ret = @cloud_stack.create_volume(name, ZONE, DISK_OFFERING)
id = ret["createvolumeresponse"]["jobid"]
wait_for_job id
vol_id = ret["createvolumeresponse"]["id"]
@log.info "Created volume id: #{vol_id... | [
"def volume_id\n data[:volume_id]\n end",
"def volume_id\n @volume_id\n end",
"def create_volume\n # the volume_id parameter is only valid for attaching nodes, not for creating\n raise 'Cannot create a volume with a specific id (CBS chooses volume ids)' if @new_resource.volume_id\n # create t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Given a list of classes, modules, strings, and symbols, compile a combined list of methods. Classes and modules will be queried for their instance methods; strings and symbols will be treated as methods names. +include_ancestors+ determines whether to include methods defined by class/module ancestors. | def collect_methods(include_ancestors, *methods_or_modules)
methods_or_modules.inject([]) {|methods, method_or_module|
case method_or_module
when Symbol, String
methods << method_or_module.to_sym
when Module # also includes classes
methods.concat(method_or_module.instan... | [
"def included_meths(opts = {})\n opts = SymbolHash[:scope => [:instance, :class]].update(opts)\n [opts[:scope]].flatten.map do |scope|\n mixins(scope).inject([]) do |list, mixin|\n next list if mixin.is_a?(Proxy)\n arr = mixin.meths(opts.merge(:scope => :instance)).reject do |o|\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /pumpers POST /pumpers.xml | def create
@timesheet = Incident.find(params[:incident_id]).timesheet
@pumper = @timesheet.pumpers.build(params[:pumper])
respond_to do |format|
if @pumper.save
format.html { redirect_to(edit_incident_timesheet_path, :notice => 'Pumper was successfully created.') }
else
format.html... | [
"def create\n @petrol_pump = PetrolPump.new(params[:petrol_pump])\n\n respond_to do |format|\n if @petrol_pump.save\n format.html { redirect_to(@petrol_pump, :notice => 'Petrol Pump entry was successfully added.') }\n format.xml { render :xml => @petrol_pump, :status => :created, :location... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /pumpers/1 PUT /pumpers/1.xml | def update
@pumper = Pumper.find(params[:id])
respond_to do |format|
if @pumper.update_attributes(params[:pumper])
format.html { redirect_to(incident_timesheet_path, :notice => 'Pumper was successfully updated.') }
format.xml { head :ok }
else
format.html { render :action =... | [
"def update opts = {}\n opts[:headers] ||= {}\n opts[:headers]['Content-Type'] ||= 'text/xml'\n post opts.fetch(:path, update_path), opts\n end",
"def update opts = {}\n opts[:headers] ||= {}\n opts[:headers]['Content-Type'] ||= 'text/xml'\n post 'update', opts\n end",
"def update\n @petr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /pumpers/1 DELETE /pumpers/1.xml | def destroy
@pumper = Pumper.find(params[:id])
@pumper.destroy
respond_to do |format|
format.html { redirect_to(incident_timesheet_path, :notice => 'Pumper was successfully deleted.') }
format.xml { head :ok }
end
end | [
"def destroy\n @pump = Pump.find(params[:id])\n @pump.destroy\n\n respond_to do |format|\n format.html { redirect_to(pumps_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @pump_line = PumpLine.find(params[:id])\n @pump_line.destroy\n\n respond_to do |format|\n fo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new tape drive. API Key Scope: tape_drives / create | def create_tape_drive_by_tape_library(tape_library_id, tape_drive_body, opts = {})
data, _status_code, _headers = create_tape_drive_by_tape_library_with_http_info(tape_library_id, tape_drive_body, opts)
data
end | [
"def create\n @drive = Drive.new(drive_params)\n\n respond_to do |format|\n if @drive.save\n format.html { redirect_to @drive, notice: 'Drive was successfully created.' }\n format.json { render :show, status: :created, location: @drive }\n else\n format.html { render :new }\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new tape drive. API Key Scope: tape_drives / create | def create_tape_drive_by_tape_library_with_http_info(tape_library_id, tape_drive_body, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: TapeDrivesApi.create_tape_drive_by_tape_library ...'
end
# verify the required parameter 'tape_library_id' is set
... | [
"def create\n @drive = Drive.new(drive_params)\n\n respond_to do |format|\n if @drive.save\n format.html { redirect_to @drive, notice: 'Drive was successfully created.' }\n format.json { render :show, status: :created, location: @drive }\n else\n format.html { render :new }\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Destroys a specific tape drive. API Key Scope: tape_drives / destroy | def destroy_tape_drive_with_http_info(tape_drive_id, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: TapeDrivesApi.destroy_tape_drive ...'
end
# verify the required parameter 'tape_drive_id' is set
if @api_client.config.client_side_validation && t... | [
"def destroy\n @drive.destroy\n respond_to do |format|\n format.html { redirect_to drives_url, notice: 'Drive was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @hard_drive.destroy\n respond_to do |format|\n format.html { redirect_to hard_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Lists all tape drives. API Key Scope: tape_drives / index | def index_tape_drives(opts = {})
data, _status_code, _headers = index_tape_drives_with_http_info(opts)
data
end | [
"def index_tape_drives_with_http_info(opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: TapeDrivesApi.index_tape_drives ...'\n end\n # resource path\n local_var_path = '/tape_drives'\n\n # query parameters\n query_params = opts[:query_p... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Lists all tape drives. API Key Scope: tape_drives / index | def index_tape_drives_with_http_info(opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: TapeDrivesApi.index_tape_drives ...'
end
# resource path
local_var_path = '/tape_drives'
# query parameters
query_params = opts[:query_params] || {}
... | [
"def index_tape_drives(opts = {})\n data, _status_code, _headers = index_tape_drives_with_http_info(opts)\n data\n end",
"def index\n @hard_drives = HardDrive.all\n end",
"def index\n @disk_types = DiskType.all\n end",
"def index\n @drive_data = DriveDatum.all\n end",
"def index\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Displays a specific tape drive. API Key Scope: tape_drives / show | def show_tape_drive(tape_drive_id, opts = {})
data, _status_code, _headers = show_tape_drive_with_http_info(tape_drive_id, opts)
data
end | [
"def show_tape_drive_with_http_info(tape_drive_id, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: TapeDrivesApi.show_tape_drive ...'\n end\n # verify the required parameter 'tape_drive_id' is set\n if @api_client.config.client_side_validation ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Displays a specific tape drive. API Key Scope: tape_drives / show | def show_tape_drive_with_http_info(tape_drive_id, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: TapeDrivesApi.show_tape_drive ...'
end
# verify the required parameter 'tape_drive_id' is set
if @api_client.config.client_side_validation && tape_dr... | [
"def show_tape_drive(tape_drive_id, opts = {})\n data, _status_code, _headers = show_tape_drive_with_http_info(tape_drive_id, opts)\n data\n end",
"def show\n @drive_system = DriveSystem.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates a specific tape drive. API Key Scope: tape_drives / update | def update_tape_drive(tape_drive_id, tape_drive_body, opts = {})
data, _status_code, _headers = update_tape_drive_with_http_info(tape_drive_id, tape_drive_body, opts)
data
end | [
"def update_tape_drive_with_http_info(tape_drive_id, tape_drive_body, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: TapeDrivesApi.update_tape_drive ...'\n end\n # verify the required parameter 'tape_drive_id' is set\n if @api_client.config.cl... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates a specific tape drive. API Key Scope: tape_drives / update | def update_tape_drive_with_http_info(tape_drive_id, tape_drive_body, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: TapeDrivesApi.update_tape_drive ...'
end
# verify the required parameter 'tape_drive_id' is set
if @api_client.config.client_side_... | [
"def update\n respond_to do |format|\n if @drive.update(drive_params)\n format.html { redirect_to '/drives', notice: 'Drive was successfully updated.' }\n format.json { render :show, status: :ok, location: @drive }\n else\n format.html { render :edit }\n format.json { render... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
unfollow for email notice type Model id Model id key email encode key | def unfollow
return render_404 if params[:type].blank? or params[:id].blank? or params[:key].blank?
email = Encoder.decode(params[:key])
return render_404 if email.blank?
Unfollower.create(:email => email,
:unfollowerable_type => params[:type].capitalize,
... | [
"def unfollow\n return render_404 if params[:type].blank? or params[:id].blank? or params[:key].blank?\n email = Encoder.decode(params[:key])\n return render_404 if email.blank?\n\n Unfollower.create(:email => email, \n :unfollowerable_type => params[:type].capitalize, \n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
returns true if this element is hydrogen | def h?
return element == "H"
end | [
"def hectare? = unit == 'hectare'",
"def homme?\n !identified? || sexe == 'H'\n end",
"def hyphenated?\n @text.include?('-')\n end",
"def ecdhe?\n type == :ECDHE\n end",
"def half_operator?\n @modes.include? 'h'\n end",
"def hetatm\n true\n end",
"def ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
calculates formal charge (method used to determine structure generation) | def formal_charge
if root?
lewis_electrons = 0
else #if an element is not the root, it is bonded to another element, thus increase the formal charge count by 1
lewis_electrons = 1
end
# if the element has nodes, look at each one
if nodes?
nodes.each { |node|
if node == nil # if the node ... | [
"def calMass(mass, charge)\n (mass + (charge.to_f * 1.00727646677)) / charge\n end",
"def generateConcreteCharges\n\t\t#For each charge factories asscociated with retail plans, generate concrete charge and total them\n\t self.retail_plan.charge_factories.each do |charge_factory| \n\t predicted_concret... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
returns true if the element can expand its octet (bond to more elements) | def expands?
return PeriodicTable.atomic_number(element) > 13
end | [
"def expandable?\n false\n end",
"def element_consumed?\n @element_consumed\n end",
"def element_consumed?\n @element_consumed\n end",
"def fit?(item)\n b = case item\n when String; item.length * 4\n when Array; item.reduce(0) { |s, i| s + i.length * 4 }\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
read_in returns the file as an array | def read_in
File.foreach(file_name).map(&:chomp)
end | [
"def _read filename\n d = []\n File.open(filename).each { |line|\n d << line\n }\n return d\n end",
"def output_file_to_array(raw_file)\n file_to_read = File.read(raw_file)\n file_to_array = file_to_read.split(\"\\n\")\n end",
"def read_from_txt(filepath)\n result_arr = []\n File.o... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
write_out Args write out rows into file | def write_out(rows)
File.open(file_name, 'w') do |f|
f.puts rows
end
end | [
"def write_output\n rows = data_to_rows\n CSV.open(@filename, 'wb') do |csv|\n rows.each {|row| csv << row}\n end\n end",
"def write_to_file\n File.open(outfile, 'w') do |out|\n out.puts header.to_s\n out.puts create_sum_row if @sum_row_pos == 'TOP'\n rows.each do |key, ro... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Assign a ticket to a locker and then add it to the reservation list | def create(ticket)
ticket.assign_available_locker_from(@lockers)
add_ticket(ticket)
end | [
"def add_ticket(ticket)\n @reservations[ticket.confirmation_number] = ticket\n end",
"def acquire!(locker)\n self.locked_by = locker\n self.locked_at = Time.now\n save!\n end",
"def reserve\n @event = Event.find(params[:id])\n\n ticket = @event.ticket\n\n raise TicketOutdated unless t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Convenience method used by the 'create' method to add a ticket to the reservations list | def add_ticket(ticket)
@reservations[ticket.confirmation_number] = ticket
end | [
"def create(ticket)\n ticket.assign_available_locker_from(@lockers)\n add_ticket(ticket)\n end",
"def create_ticket\n\n end",
"def addToTicket\n\t ticket = Ticket.where(table: session[:table_id]).last\n\t if (ticket.nil?) || (ticket.tstatus == 9)\n\t ticket = Ticket.create(table: session[:t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Remote a ticket from the the reservation list and free up the locker it used | def remove_ticket(ticket)
@lockers.unassign(ticket)
@reservations.delete(ticket.confirmation_number)
end | [
"def request_reservation\n result = PrioTicket::API.call(request_body, identifier)\n parse_result(result)\n end",
"def create(ticket)\n ticket.assign_available_locker_from(@lockers)\n add_ticket(ticket)\n end",
"def unassign(ticket)\n send(ticket.bag_size)[ticket.locker_number] = ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Proxy method over to the lockers object to simulate locker rooms being fully occupied | def fill_locker_room_for(locker_type)
lockers.fill_locker_room_for(locker_type)
end | [
"def block_room\n\t\tself.room.set_occupied\n\tend",
"def locker\n @locker ||= (superclass.locker if superclass.respond_to?(:locker))\n end",
"def object_lock_legal_hold_status; end",
"def lock\n if unlocked_status == false\n raise ArgumentError.new(\"You cannot lock ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Make voice calls through the browser. This web request gets called by Twilio based on your Twilio settings, which can be modified at | def voice
from_number = params['FromNumber'].blank? ? ENV['TWILIO_CALLER_ID'] : params['FromNumber']
twiml = Twilio::TwiML::Response.new do |r|
if params['To'] and params['To'] != ''
r.Dial callerId: from_number do |d|
# wrap the phone number or client name in the appropriate TwiML verb
... | [
"def start\n @call = Call.create(sid: params[:CallSid], from: params[:Caller], status: params[:CallStatus])\n response = Twilio::TwiML::VoiceResponse.new\n response.gather(action: '/ivr/response', method: 'POST') do |gather|\n gather.say(message: 'Thank you for calling Zayne. Please press 1 to reach h... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /espetaculos POST /espetaculos.json | def create
@espetaculo = Espetaculo.new(espetaculo_params)
respond_to do |format|
if @espetaculo.save
format.html { redirect_to @espetaculo, notice: 'Espetaculo was successfully created.' }
format.json { render :show, status: :created, location: @espetaculo }
else
format.htm... | [
"def create\n @establecimiento = Establecimiento.new(establecimiento_params)\n\n if @establecimiento.save\n render json: @establecimiento, status: :created, location: @establecimiento\n else\n render json: @establecimiento.errors, status: :unprocessable_entity\n end\n end",
"def create\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /insurances/new GET /insurances/new.json | def new
@breadcrumb = 'create'
@insurance = Insurance.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @insurance }
end
end | [
"def new\n @insurance = Insurance.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @insurance }\n end\n end",
"def new\n @insurance_type = InsuranceType.new\n @title = \"New Insurance Type\"\n \n respond_to do |format|\n format.html # ne... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /insurances POST /insurances.json | def create
@breadcrumb = 'create'
@insurance = Insurance.new(params[:insurance])
@insurance.created_by = current_user.id if !current_user.nil?
respond_to do |format|
if @insurance.save
format.html { redirect_to @insurance, notice: crud_notice('created', @insurance) }
... | [
"def create(params = {})\n wrapped_params = { insurance: params }\n @client.make_request(:post, 'insurances', MODEL_CLASS, wrapped_params)\n end",
"def create\n @insurance = Insurance.new(params[:insurance])\n\n respond_to do |format|\n if @insurance.save\n format.html { redirect_to @insu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /insurances/1 PUT /insurances/1.json | def update
@breadcrumb = 'update'
@insurance = Insurance.find(params[:id])
@insurance.updated_by = current_user.id if !current_user.nil?
respond_to do |format|
if @insurance.update_attributes(params[:insurance])
format.html { redirect_to @insurance,
n... | [
"def update\n @insurance = Insurance.find(params[:id])\n\n respond_to do |format|\n if @insurance.update_attributes(params[:insurance])\n format.html { redirect_to @insurance, notice: 'Insurance was successfully updated.' }\n format.json { head :no_content }\n else\n format.html... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns an array of all the galleries that an artist has paintings in | def galleries
Painting.all.map do |painting_instance|
if painting_instance.artist == self
painting_instance.gallery
end
end.compact.uniq
end | [
"def all_galleries_by_artist\n all_paintings_by_artist.map do |painting|\n painting.gallery\n end\n end",
"def all_galleries #list of all galeries with paintings of an artist (done)\n paintings.map do |painting|\n painting.gallery\n end\nend",
"def gallery \n paintings.map{|artist| artist.ga... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return an array of all cities that an artist has paintings in | def cities
Painting.all.map do |painting_instance|
if painting_instance.artist == self
painting_instance.gallery.city
end
end.compact.uniq
end | [
"def cities_with_artist\n gal_with_artist.map do |painting|\n painting.city\n end\n end",
"def all_cities_by_artist\n all_galleries_by_artist.map do |gallery|\n gallery.city\n end\n end",
"def cities\n\t\tCity.cities_in_country('SE')\n\tend",
"def visiting_cities\n return [] if stop... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Redirect to '/spslo' is required for SP initiated Single Logout | def after_sign_out_path_for(_)
if session['saml_uid'] && session['saml_session_index'] && SAML_SETTINGS.idp_slo_service_url
user_saml_omniauth_authorize_path(locale: nil) + '/spslo'
else
super
end
end | [
"def ssoe_slo_url\n Settings.saml_ssoe.logout_url\n end",
"def redirect_after_dsi_signout\n if params[:state] == 'support'\n redirect_to support_interface_path\n else\n redirect_to provider_interface_path\n end\n end",
"def sso\n target_url = params['targetUrl']\n redirect_link... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Declares which content models will be included with the model EXAMPLE: has_content :articles, :tips | def has_yaml_content(*args)
include HasYamlContent::InstanceMethods
#get the already loaded content modules
content_types = custom_content_types
args.each do |arg|
#load content model
if arg.is_a?(Symbol)
#singularize content model and append to array
... | [
"def associate_related_content(content)\n return if params.dig(:content, :content_to_content).blank?\n\n content.content_to_content = []\n content_params[:content_to_content]&.each do |content_to_content|\n content.content_to_content << content_to_content\n end\n end",
"def assert_co... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the content model class | def get_content_model(model_name)
model_hash = content_types.select{|x| x[:name] == model_name}.first
return model_hash[:class_name].nil? ? model_name.constantize : model_hash[:class_name].constantize
end | [
"def content_class\n return @content_class if @content_class\n\n if self.sub_content_type.nil? || self.sub_content_type == 'ContentCopy'\n content_class = self.sub_content_type.nil? ? self.content.class : self.content.copied_content_class\n @content_class = content_class unless content_class == Cont... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Take the given hash and category, and set its children as appropriate | def set_children_for(category, hash)
if hash['children']
hash['children'].each do |ch|
child = Documents::Category.find(ch['id'])
child.parent = category
child.save
set_children_for(child, ch)
end
else
# Can't remove children, so nil out the p... | [
"def populate_categories(structure, category_ids)\n struct = structure.deep_dup\n struct[\"sections\"].each do |s|\n next unless s[\"kind\"] == \"categories\"\n\n s[\"categories\"].each_with_index do |c, i|\n c[\"category\"][\"id\"] = category_ids[i]\n end\n end\n struct\nend",
"def attach_categ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /challenges GET /challenges.xml | def index
@challenges = Challenge.all
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @challenges }
end
end | [
"def show\n @challenges = Challenge.find(params[:id])\n render json: @challenges\n end",
"def index\n @challenges = Challenge.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @challenges }\n end\n end",
"def show\n @challenge = Challe... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /challenges/new GET /challenges/new.xml | def new
@challenge = Challenge.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @challenge }
end
end | [
"def new\n if logged_in?\n @challenge = current_user.challenges.new\n else\n @challenge = Challenge.unassigned.new\n end\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @challenge }\n end\n end",
"def new\n @challenge = Challenge.new\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /challenges POST /challenges.xml | def create
@challenge = Challenge.new(params[:challenge])
respond_to do |format|
if @challenge.save
flash[:notice] = 'Challenge was successfully created.'
format.html { redirect_to(@challenge) }
format.xml { render :xml => @challenge, :status => :created, :location => @challenge ... | [
"def create\n @challenge = Challenge.new(params[:challenge])\n\n respond_to do |format|\n if @challenge.save\n format.html { redirect_to(@challenge, :notice => 'Challenge was successfully created.') }\n format.xml { render :xml => @challenge, :status => :created, :location => @challenge }\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /challenges/1 PUT /challenges/1.xml | def update
@challenge = Challenge.find(params[:id])
respond_to do |format|
if @challenge.update_attributes(params[:challenge])
flash[:notice] = 'Challenge was successfully updated.'
format.html { redirect_to(@challenge) }
format.xml { head :ok }
else
format.html { r... | [
"def update\n expose Challenge.update(@oauth_token, params[:challenge_id].strip,\n params[:data])\n end",
"def update\n @challenge ||= Challenge.find(params[:id])\n\n respond_to do |format|\n if @challenge.update_attributes(params[:challenge])\n format.html { redirect_to @challenge, not... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /challenges/1 DELETE /challenges/1.xml | def destroy
@challenge = Challenge.find(params[:id])
@challenge.destroy
respond_to do |format|
format.html { redirect_to(challenges_url) }
format.xml { head :ok }
end
end | [
"def destroy\n @challenge.destroy\n\n respond_to do |format|\n format.html { redirect_to(challenges_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @concert = Concert.find(params[:id])\n @concert.destroy\n\n respond_to do |format|\n format.html { redirect_to(concer... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Fetch new IP Address from first_ip and index function | def fetch_ip_address(first_ip, i)
array = first_ip.split('.')
change = (array.first 3).push(array[-1].to_i + i)
new_ip = ""
for i in change
new_ip += "." + i.to_s
end
return new_ip[1..-1]
end | [
"def test_ip(index=258)\n ips = @gogrid.list_ips\n ips[index][\"ip\"]\n #puts ips.collect {|ip| ip[\"ip\"] + \", \" }\n end",
"def next_assigned\n Ip.find(:first, :conditions => \n ['address_i > ? AND service = ? and network_id is not null', self.address_i, self.service], :order => 'address_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Public Methods callseq: Kconv.kconv(str, out_code, in_code = Kconv::AUTO) Convert str to out_code. out_code and in_code are given as constants of Kconv. Note This method decode MIME encoded string and convert halfwidth katakana to fullwidth katakana. If you don't want to decode them, use NKF.nkf. | def kconv(str, out_code, in_code = AUTO)
opt = '-'
case in_code
when ::NKF::JIS
opt << 'J'
when ::NKF::EUC
opt << 'E'
when ::NKF::SJIS
opt << 'S'
when ::NKF::UTF8
opt << 'W'
when ::NKF::UTF16
opt << 'W16'
end
case out_code
when ::NKF::JIS
opt ... | [
"def unicode_normalize_kc(input); end",
"def to_katakana(src)\n src\n .gsub(\"わ゙\",\"ヷ\")\n .gsub(\"い゙\",\"ヸ\")\n .gsub(\"え゙\",\"ヹ\")\n .gsub(\"を゙\",\"ヺ\")\n .tr(\"ぁ-ゖゝゞゟ\",\"ァ-ヶヽヾヿ\")\nend",
"def to_katakana\n NKF.nkf('-w --katakana', self)\n end",
"def to_hw_katakana\n # At first, convert to fu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.