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 |
|---|---|---|---|---|---|---|
Override the accessor: The Jekyll::Rendereer calls document.content, so this seems like the best way to set our "page" content with what we want. | def content
zones = {}
keys = %w[content preferences]
if page['block_instances'].length
# create zone buckets
page['block_instances'].each do |i|
# go through all content
if site.config.event?
keys.each do |key|
i[key].ea... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def content\n return @content if @content\n content, id = self.get_page_content\n content = master.render(content)\n Ruhoh::Converter.convert(content, id)\n end",
"def set_resource_content\n @page = Page.available.homepage.first!\n end",
"def documentation_content_for(page)\n ... | [
"0.68852824",
"0.67624646",
"0.67619675",
"0.6447814",
"0.6438497",
"0.6417692",
"0.6417692",
"0.6417692",
"0.6417692",
"0.6417692",
"0.6417692",
"0.63165885",
"0.61453617",
"0.61395913",
"0.6132145",
"0.6120535",
"0.6111205",
"0.608347",
"0.6077901",
"0.60763055",
"0.6067383... | 0.0 | -1 |
marking objects for destruction brute force version. Only works if you save parent. Going through each element and destroy it is not very efficient | def mark_children_for_removal
work_graphics.each do |work_graphic|
work_graphic.destroy
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n #primitives in structs are without parent\n parent and parent.children.delete self\n end",
"def destroy\n self.littles.each do | little|\n little.big_id = nil;\n end\n self.positions.each do | pos |\n pos.dke_info_id = nil;\n end\n return super\n end",
"def ... | [
"0.6851682",
"0.6746977",
"0.6646924",
"0.65748346",
"0.64702755",
"0.64254194",
"0.63182765",
"0.62679046",
"0.61741376",
"0.61004126",
"0.6043362",
"0.60281384",
"0.6025435",
"0.60194993",
"0.60027665",
"0.59834915",
"0.5973925",
"0.59564304",
"0.59363323",
"0.59327054",
"0... | 0.639375 | 6 |
=============================================================================== helper de cadastro | def texto_longo_ecm_new_cadastro_item(form_item, params)
view = ""
unless params
view.concat(text_area :cadastro, "item_#{form_item.id}", options={:cols=>form_item.opcoes[:largura], :rows=>form_item.opcoes[:altura]})
else
view.concat(text_area :cadastro, "item_#{form_item.id}", options={:value=>... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mi_carrera\n\n\tend",
"def set_cadastro\n @cadastro = Cadastro.find(params[:id])\n end",
"def agregar_compra(producto, unidades = 1)\n DB.execute(\"insert into compras values ( ?, ?)\", producto, unidades)\nend",
"def suivre; end",
"def diario\n fechas()\n @ejercicios = Ejercicio.find(:a... | [
"0.6171839",
"0.59500235",
"0.5908083",
"0.58400655",
"0.58154124",
"0.5770937",
"0.5720225",
"0.56514174",
"0.5649546",
"0.56271476",
"0.56078136",
"0.5564297",
"0.556201",
"0.5546432",
"0.55187553",
"0.5514774",
"0.5500641",
"0.5500641",
"0.5500641",
"0.5492789",
"0.5489904... | 0.0 | -1 |
Reset counters in seller when change the seller of store | def reset_seller_counters(store)
# Reset counter cache to new seller
Seller.reset_counters(store.seller_id, :stores)
# Recount all stores_count for all sellers tree
SellerAppCountWorker.perform_at(1.minutes.from_now, store.seller.id)
if store.seller_id_was && Seller.exists?(store.seller_id_was)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_counter_cache\n User.reset_counters(@listing.seller_id, :active_listings)\n end",
"def hire_seller\r\n\t\t@sellers += 1\r\n\t\tputs \"*\"*50\r\n\t\tputs \"You just hired a new seller, you now have #{@sellers} sellers working for you.\"\r\n\t\tputs \"*\"*50\r\n\tend",
"def recount_actives_stores(... | [
"0.68718934",
"0.6710743",
"0.62266004",
"0.59057367",
"0.5828847",
"0.5812863",
"0.58118725",
"0.5791982",
"0.5791982",
"0.5791982",
"0.5791982",
"0.5791982",
"0.5791982",
"0.5769071",
"0.5741195",
"0.56977665",
"0.5670078",
"0.56671",
"0.5660644",
"0.5642519",
"0.56270856",... | 0.8447676 | 0 |
Public: Creates a snapshot for a VM. The VM must be running in order to create a snapshot. Snapshot names must be unique. name The desired name of the snapshot. The name must be unique. Examples | def create_snapshot(name)
unless exists?
return Response.new :code => 1, :message => 'VM does not exist'
end
running_response = running?
return running_response unless running_response.successful?
unless running_response.data
message = 'The VM must be running in order to ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_snapshot(snapshot_name)\n execute(:create_snapshot, VmId: vm_id, SnapName: snapshot_name)\n end",
"def create_snapshot(name)\n Fission::Action::Snapshot::Creator.new(self).create_snapshot(name)\n end",
"def create_snapshot(snap_id, snap_name)\n memory_dumps = true\n ... | [
"0.87295747",
"0.8101503",
"0.7989879",
"0.7883372",
"0.77501374",
"0.73471594",
"0.7126852",
"0.6777018",
"0.6686673",
"0.66147506",
"0.65359205",
"0.6513703",
"0.64694715",
"0.644606",
"0.63948697",
"0.6331971",
"0.6325482",
"0.62572885",
"0.6255418",
"0.6215297",
"0.619974... | 0.847478 | 1 |
Public: Reverts the VM to the specified snapshot. The snapshot to revert to must exist and the Fusion GUI must not be running. name The snapshot name to revert to. Examples | def revert_to_snapshot(name)
unless exists?
return Response.new :code => 1, :message => 'VM does not exist'
end
if Fusion.running?
message = 'It looks like the Fusion GUI is currently running. '
message << 'A VM cannot be reverted to a snapshot when the Fusion GUI is running.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def revert_to_snapshot(name)\n raise Fission::Error,\"VM #{@name} does not exist\" unless self.exists?\n\n command = \"#{vmrun_cmd} revertToSnapshot #{vmx_path.shellescape} \\\"#{name}\\\" 2>&1\"\n output = `#{command}`\n\n response = Fission::Response.new :code => $?.exitstatus\n response... | [
"0.8358712",
"0.83442545",
"0.7905424",
"0.7835717",
"0.73976845",
"0.6691044",
"0.6623359",
"0.6483487",
"0.63131666",
"0.6285355",
"0.61799955",
"0.61680114",
"0.6142899",
"0.61428314",
"0.6123987",
"0.6114518",
"0.6073976",
"0.59369624",
"0.5795219",
"0.5753843",
"0.563419... | 0.84456444 | 0 |
Public: List the snapshots for a VM. Examples | def snapshots
unless exists?
return Response.new :code => 1, :message => 'VM does not exist'
end
conf_file_response = conf_file
return conf_file_response unless conf_file_response.successful?
command = "#{vmrun_cmd} listSnapshots "
command << "#{conf_file_response.data} 2>&... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def snapshots\n raise Fission::Error,\"VM #{@name} does not exist\" unless self.exists?\n\n command = \"#{vmrun_cmd} listSnapshots #{vmx_path.shellescape} 2>&1\"\n output = `#{command}`\n\n raise \"There was an error listing the snapshots of #{@name} :\\n #{output}\" unless $?.exitstatus==0\n\... | [
"0.8300678",
"0.8081066",
"0.80803514",
"0.7840411",
"0.7684221",
"0.74065936",
"0.7338083",
"0.7323141",
"0.7128714",
"0.71278566",
"0.7087461",
"0.7066364",
"0.7021482",
"0.7017439",
"0.7007793",
"0.6985959",
"0.67653114",
"0.6729876",
"0.67017585",
"0.6624287",
"0.6563861"... | 0.7795029 | 4 |
Public: Starts a VM. The VM must not be running in order to start it. options Hash of options: :headless Boolean which specifies to start the VM without a GUI console. The Fusion GUI must not be running in order to start the VM headless. (default: false) Examples | def start(options={})
unless exists?
return Response.new :code => 1, :message => 'VM does not exist'
end
running_response = running?
return running_response unless running_response.successful?
if running_response.data
return Response.new :code => 1, :message => 'VM is alr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start(options={})\n unless @vm.exists?\n return Response.new :code => 1, :message => 'VM does not exist'\n end\n\n running_response = @vm.running?\n return running_response unless running_response.successful?\n\n if running_response.data\n retu... | [
"0.8063125",
"0.7371226",
"0.72947097",
"0.6703487",
"0.66851383",
"0.6637769",
"0.63795877",
"0.6048234",
"0.6026887",
"0.60018075",
"0.59982306",
"0.5958771",
"0.59550554",
"0.5914051",
"0.58915216",
"0.5859023",
"0.58584094",
"0.5856711",
"0.5852507",
"0.5768819",
"0.57680... | 0.80328715 | 1 |
Public: Stops a VM. The VM must be running in order to stop it. options Hash of options: :hard Boolean which specifies to power off the VM (instead of attempting to initiate a graceful shutdown). This is the equivalent of passing 'hard' to the vmrun stop command. (default: false) Examples | def stop(options={})
unless exists?
return Response.new :code => 1, :message => 'VM does not exist'
end
running_response = running?
return running_response unless running_response.successful?
unless running_response.data
return Response.new :code => 1, :message => 'VM is ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop(options={})\n Fission::Action::VM::Stopper.new(self).stop(options)\n end",
"def halt_fusion_vm(options)\n stop_fusion_vm(options)\nend",
"def force_stop(options={})\n @state.value = State::STOPPED\n @cartridge_model.create_stop_lock\n @container_plugin.stop(options)\n ... | [
"0.7952278",
"0.71565455",
"0.6723032",
"0.6444872",
"0.6229081",
"0.62088543",
"0.6152392",
"0.61098343",
"0.60134584",
"0.5987258",
"0.595926",
"0.5947789",
"0.58820486",
"0.5866406",
"0.586381",
"0.58149314",
"0.5808411",
"0.5782733",
"0.5781018",
"0.577224",
"0.57667756",... | 0.81308055 | 0 |
Public: Suspends a VM. The VM must be running in order to suspend it. Examples | def suspend
unless exists?
return Response.new :code => 1, :message => 'VM does not exist'
end
running_response = running?
return running_response unless running_response.successful?
unless running_response.data
return Response.new :code => 1, :message => 'VM is not runni... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def suspend\n execute(\"controlvm\", @uuid, \"savestate\")\n end",
"def suspend\n Fission::Action::VM::Suspender.new(self).suspend\n end",
"def suspend\n execute_prlctl('suspend', @uuid)\n end",
"def suspend\n requires :id\n begin\n response = ... | [
"0.72526103",
"0.674012",
"0.655616",
"0.63345",
"0.6240721",
"0.62070835",
"0.6192826",
"0.6139993",
"0.6128174",
"0.6116592",
"0.597085",
"0.57992333",
"0.57641864",
"0.57539874",
"0.57539874",
"0.5694305",
"0.5680789",
"0.56572825",
"0.5650772",
"0.55372185",
"0.5509754",
... | 0.6477853 | 3 |
Public: Provides the MAC addresses for a VM. Examples: | def mac_addresses
network_response = network_info
return network_response unless network_response.successful?
response = Response.new :code => 0
response.data = network_response.data.values.collect { |n| n['mac_address'] }
response
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_mac_addresses\n read_vm_option('mac').strip.gsub(':', '').split(' ')\n end",
"def read_mac_address\n execute(:get_network_mac, VmId: vm_id)\n end",
"def mac_address\n mac = nil\n\n ovf.xpath(\"//*[local-name()='Machine']/*[local-name()='Hardware']/*[local-name... | [
"0.7692694",
"0.74545956",
"0.7099549",
"0.70928115",
"0.70827186",
"0.7019374",
"0.6979955",
"0.68134606",
"0.68021387",
"0.67451507",
"0.67300785",
"0.6715417",
"0.6691889",
"0.65320915",
"0.65040594",
"0.65022993",
"0.63408506",
"0.63189",
"0.6315108",
"0.63004774",
"0.627... | 0.72958803 | 3 |
Public: Provides the state of the VM. Examples | def state
running_response = running?
return running_response unless running_response.successful?
response = Response.new :code => 0, :data => 'not running'
if running_response.data
response.data = 'running'
else
suspended_response = suspended?
return suspended_re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def state(vm_name)\n `VBoxManage showvminfo #{vm_name}` =~ /^State:\\s+(.*)$/ ? $1 : 'unknown'\n end",
"def read_state\n read_vm_option('status').strip.to_sym\n end",
"def get_current_state\n execute(:get_vm_status, VmId: vm_id)\n end",
"def read_state\n output ... | [
"0.66668713",
"0.66076",
"0.6602058",
"0.6538977",
"0.6533354",
"0.64973766",
"0.64890385",
"0.64790255",
"0.64336526",
"0.6419743",
"0.63984644",
"0.63975495",
"0.6395126",
"0.6390423",
"0.6379748",
"0.6374456",
"0.6364532",
"0.6360513",
"0.6352875",
"0.63508016",
"0.6344633... | 0.0 | -1 |
Public: Determines if the VM exists or not. This method looks for the VM's conf file ('.vmx') to determine if the VM exists or not. Examples | def exists?
conf_file.successful?
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exists?\n File.exists? vmx_path\n end",
"def check_fusion_vm_exists(options)\n set_vmrun_bin(options)\n if options['host-os-name'].to_s.match(/Linux/)\n fusion_vm_dir = options['fusiondir']+\"/\"+options['name']\n else\n fusion_vm_dir = options['fusiondir']+\"/\"+options['name']+\".vmwarevm\... | [
"0.7622194",
"0.754773",
"0.7458194",
"0.7458194",
"0.72291404",
"0.71238846",
"0.7053148",
"0.69420063",
"0.6885644",
"0.6843978",
"0.68160194",
"0.68004954",
"0.6784",
"0.67590314",
"0.6726877",
"0.6713914",
"0.6643735",
"0.66268003",
"0.65253115",
"0.6507069",
"0.64989924"... | 0.58102995 | 43 |
Public: Determines if a VM is suspended. Examples | def suspended?
running_response = running?
return running_response unless running_response.successful?
response = Response.new :code => 0, :data => false
response.data = suspend_file_exists? unless running_response.data
response
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def suspended?\n status.suspended?\n end",
"def suspended?\n (status == SUSPENDED)\n end",
"def suspended?\n !active?\n end",
"def suspended?()\n #This is a stub, used for indexing\n end",
"def suspended?\n (status == SUSPEND)\n end",
"def is_suspended?\n current_... | [
"0.7707653",
"0.7624279",
"0.7370699",
"0.7369654",
"0.73558897",
"0.68175644",
"0.6817079",
"0.6506195",
"0.64723384",
"0.64467597",
"0.63937956",
"0.6337369",
"0.63169354",
"0.63122475",
"0.62116605",
"0.6162644",
"0.615737",
"0.6099624",
"0.6099624",
"0.60401946",
"0.60336... | 0.630387 | 14 |
Public: Determines if a VM has a suspend file ('.vmem') in it's directory. This only looks for a suspend file which matches the name of the VM. Examples | def suspend_file_exists?
File.file? File.join(path, "#{@name}.vmem")
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def suspend\n unless exists?\n return Response.new :code => 1, :message => 'VM does not exist'\n end\n\n running_response = running?\n return running_response unless running_response.successful?\n\n unless running_response.data\n return Response.new :code => 1, :message => 'V... | [
"0.5882661",
"0.5777305",
"0.576586",
"0.57584304",
"0.5748528",
"0.5652615",
"0.54903674",
"0.54500395",
"0.54241735",
"0.54192775",
"0.5355263",
"0.5355263",
"0.5311403",
"0.5243774",
"0.5243667",
"0.5243667",
"0.52360857",
"0.52010655",
"0.5191226",
"0.5185978",
"0.5177669... | 0.7517683 | 1 |
Public: Determines if a VM is running. Examples | def running?
all_running_response = self.class.all_running
return all_running_response unless all_running_response.successful?
response = Response.new :code => 0, :data => false
if all_running_response.data.collect { |v| v.name }.include? @name
response.data = true
end
res... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def running\n\t @vm_running = Virtualmachine.isrunning\n end",
"def vm_running?\n `docker-machine ls | grep #{project_config['docker-machine']['name']}` =~ /running/i ? true : false\nend",
"def vm_ok?\n unless @vm\n warn 'No VM initialized'\n return false\n end\n inf = vm_info\n... | [
"0.8204294",
"0.77401966",
"0.7664043",
"0.7388182",
"0.73449606",
"0.7291203",
"0.7264888",
"0.713769",
"0.7125689",
"0.712245",
"0.70647603",
"0.70549226",
"0.7054564",
"0.69614667",
"0.6945672",
"0.6945672",
"0.6945672",
"0.69407046",
"0.6922534",
"0.6914648",
"0.6912643",... | 0.0 | -1 |
Public: Determines the path to the VM's config file ('.vmx'). Examples | def conf_file
vmx_path = File.join path, "*.vmx"
conf_files = Dir.glob vmx_path
response = Response.new
case conf_files.count
when 0
response.code = 1
response.message = "Unable to find a config file for VM '#{@name}' (in '#{vmx_path}')"
when 1
response.code... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vmx_path\n return File.join(path, \"#{@name}.vmx\")\n end",
"def path\n File.join Fission.config.attributes['vm_dir'], \"#{@name}.vmwarevm\"\n end",
"def path\n File.join Fission.config['vm_dir'], \"#{@name}.vmwarevm\"\n end",
"def path\n File.join Fission.config['vm_dir'], \... | [
"0.7842283",
"0.775856",
"0.7737295",
"0.7737295",
"0.7139698",
"0.70410436",
"0.69512856",
"0.66847956",
"0.666324",
"0.65464497",
"0.65182424",
"0.64154017",
"0.63584983",
"0.6341152",
"0.63227695",
"0.6321877",
"0.6313751",
"0.63087255",
"0.62857175",
"0.6284578",
"0.62738... | 0.7224048 | 4 |
Public: Provides the expected path to a VM's directory. This does not imply that the VM or path exists. name The name of the VM to provide the path for. Examples | def path
File.join Fission.config['vm_dir'], "#{@name}.vmwarevm"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def path\n File.join Fission.config.attributes['vm_dir'], \"#{@name}.vmwarevm\"\n end",
"def path(name=nil)\n if name\n return @dir + '/' + name\n else\n return @dir\n end\n end",
"def vagrant_box(name)\n result = boxes_path.join(name)\n FileUtils.mkdir_p(result)\n re... | [
"0.6807978",
"0.65036577",
"0.6354682",
"0.6059271",
"0.60238516",
"0.5988303",
"0.5812387",
"0.57191455",
"0.5660093",
"0.5637171",
"0.55512977",
"0.5549756",
"0.55132025",
"0.5470299",
"0.5448806",
"0.5448806",
"0.5438736",
"0.5437756",
"0.5437428",
"0.5419269",
"0.53777117... | 0.68357503 | 1 |
Public: Deletes a VM. The VM must not be running in order to delete it. As there are a number issues with the Fusion command line tool for deleting VMs, this is a best effort. The VM must not be running when this method is called. This essentially deletes the VM directory and attempts to remove the relevant entries fro... | def delete
unless exists?
return Response.new :code => 1, :message => 'VM does not exist'
end
running_response = running?
return running_response unless running_response.successful?
if running_response.data
message = 'The VM must not be running in order to delete it.'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete\n unless @vm.exists?\n return Response.new :code => 1, :message => 'VM does not exist'\n end\n\n running_response = @vm.running?\n return running_response unless running_response.successful?\n\n if running_response.data\n message = 'The ... | [
"0.783307",
"0.7668545",
"0.7576776",
"0.7350829",
"0.71360725",
"0.70495564",
"0.6981492",
"0.6955153",
"0.6829678",
"0.6660791",
"0.6660105",
"0.66413295",
"0.66387916",
"0.65960497",
"0.65945834",
"0.6533798",
"0.64958787",
"0.64371127",
"0.63971364",
"0.6387111",
"0.63643... | 0.7764674 | 1 |
Internal: Helper for getting the configured vmrun_cmd value. Examples | def vmrun_cmd
Fission.config['vmrun_cmd']
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vmrun_cmd\n Fission.config['vmrun_cmd']\n end",
"def vmrun_cmd\n Fission.config['vmrun_cmd']\n end",
"def vmrun_cmd\n Fission.config['vmrun_cmd']\n end",
"def vmrun_cmd\n Fission.config['vmrun_cmd']\n end",
"def vmm_command_line\n retur... | [
"0.8105079",
"0.8105079",
"0.8105079",
"0.8105079",
"0.6743608",
"0.59995025",
"0.58677274",
"0.5789821",
"0.5727923",
"0.5633322",
"0.5628246",
"0.56238335",
"0.5592715",
"0.5584428",
"0.55658007",
"0.5538986",
"0.55275685",
"0.5470546",
"0.5460587",
"0.54174024",
"0.5414408... | 0.8133074 | 1 |
GET /issue_areas GET /issue_areas.json | def index
@issue_areas = IssueArea.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def areas\n aux = WorkOrderArea.by_name\n render json: serialized_work_order_areas(aux)\n end",
"def areas\n @area = Area.new(geo_json: params.to_json)\n if @area.save\n json_response([id: @area.id], :created, :geo_json_recieved)\n else\n json_response(nil, :error, :db_error)\n ... | [
"0.70127183",
"0.6727345",
"0.66888404",
"0.6558727",
"0.65512115",
"0.6534904",
"0.64769685",
"0.6413627",
"0.63966495",
"0.63444394",
"0.6341734",
"0.6323693",
"0.630118",
"0.62706697",
"0.6158841",
"0.61516535",
"0.6138727",
"0.6120565",
"0.6110637",
"0.609412",
"0.6085813... | 0.79893744 | 0 |
GET /issue_areas/1 GET /issue_areas/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @issue_areas = IssueArea.all\n end",
"def set_issue_area\n @issue_area = IssueArea.find(params[:id])\n end",
"def area\n popolo.areas.find_by(id: area_id)\n end",
"def create\n @issue_area = IssueArea.new(issue_area_params)\n\n respond_to do |format|\n if @issue_are... | [
"0.7761095",
"0.6578399",
"0.6543199",
"0.6533289",
"0.6496538",
"0.646605",
"0.6439099",
"0.6422843",
"0.64179593",
"0.640564",
"0.6398376",
"0.6366962",
"0.6359093",
"0.6271248",
"0.6251754",
"0.6250936",
"0.6235553",
"0.619187",
"0.6141472",
"0.6131239",
"0.60808593",
"0... | 0.0 | -1 |
POST /issue_areas POST /issue_areas.json | def create
@issue_area = IssueArea.new(issue_area_params)
respond_to do |format|
if @issue_area.save
format.html { redirect_to @issue_area, notice: 'Issue area was successfully created.' }
format.json { render :show, status: :created, location: @issue_area }
else
format.html... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def areas\n @area = Area.new(geo_json: params.to_json)\n if @area.save\n json_response([id: @area.id], :created, :geo_json_recieved)\n else\n json_response(nil, :error, :db_error)\n end\n end",
"def index\n @issue_areas = IssueArea.all\n end",
"def issue_area_params\n params.req... | [
"0.6930734",
"0.6652359",
"0.6537024",
"0.6382811",
"0.62683016",
"0.62683016",
"0.6191356",
"0.6113902",
"0.60869265",
"0.6041581",
"0.59948945",
"0.5951343",
"0.58914816",
"0.58670884",
"0.58535504",
"0.5826219",
"0.58185035",
"0.5800887",
"0.5790258",
"0.5739498",
"0.57390... | 0.74074733 | 0 |
PATCH/PUT /issue_areas/1 PATCH/PUT /issue_areas/1.json | def update
respond_to do |format|
if @issue_area.update(issue_area_params)
format.html { redirect_to @issue_area, notice: 'Issue area was successfully updated.' }
format.json { render :show, status: :ok, location: @issue_area }
else
format.html { render :edit }
format.jso... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @area = Area.find(params[:id])\n\n respond_to do |format|\n if @area.update_attributes(params[:area])\n format.html { redirect_to @area, notice: 'Area was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n... | [
"0.6479621",
"0.6479621",
"0.6479621",
"0.63736206",
"0.6260628",
"0.6223009",
"0.61924714",
"0.61846274",
"0.6142388",
"0.6111292",
"0.61105484",
"0.6103904",
"0.5962165",
"0.5955237",
"0.59473336",
"0.59217215",
"0.5919821",
"0.58968246",
"0.5896768",
"0.5896302",
"0.588780... | 0.72290885 | 0 |
DELETE /issue_areas/1 DELETE /issue_areas/1.json | def destroy
@issue_area.destroy
respond_to do |format|
format.html { redirect_to issue_areas_url, notice: 'Issue area was successfully destroyed.' }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @area = Area.find(params[:id])\n @area.destroy\n\n respond_to do |format|\n format.html { redirect_to areas_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @area = Area.find(params[:id])\n @area.destroy\n\n respond_to do |format|\n format.h... | [
"0.7194692",
"0.7194692",
"0.7194692",
"0.7048286",
"0.69548094",
"0.69177425",
"0.6882465",
"0.6877776",
"0.6877776",
"0.6862402",
"0.6862246",
"0.68579644",
"0.685396",
"0.684552",
"0.6825438",
"0.68250924",
"0.682498",
"0.6789736",
"0.6783404",
"0.677249",
"0.6748169",
"... | 0.7535661 | 0 |
Use callbacks to share common setup or constraints between actions. | def set_issue_area
@issue_area = IssueArea.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 issue_area_params
params.require(:issue_area).permit(:name)
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.6978086",
"0.6780264",
"0.6742658",
"0.6738813",
"0.67338693",
"0.65908474",
"0.6501793",
"0.6495506",
"0.64796513",
"0.64755446",
"0.6454826",
"0.6437561",
"0.6377127",
"0.63722163",
"0.6364058",
"0.63178706",
"0.62979764",
"0.62968165",
"0.62913024",
"0.6289789",
"0.6289... | 0.0 | -1 |
The following line would run the calculate function calculate(1,1) | def prompt_numbers
puts "Give me a number"
a = gets.chomp.to_f
puts "Give me another number"
b = gets.chomp.to_f
return a, b
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculation\n end",
"def calculate\n (2 + 2) * 2\nend",
"def calculate!\n calculate_amount\n calculate_fee\n calculate_insurance\n calculate_deposit\n end",
"def calculate(a,b,c)\n s = a * b* c \n end",
"def add(x,y)\n total = x + y\n puts total\n calculate(total)\nend",
"def cal... | [
"0.74688274",
"0.74355286",
"0.7231579",
"0.70753103",
"0.69653946",
"0.6760296",
"0.6726776",
"0.6715163",
"0.6704213",
"0.6692412",
"0.667871",
"0.66573507",
"0.662741",
"0.6613849",
"0.66029924",
"0.65868723",
"0.6584611",
"0.6552796",
"0.6539509",
"0.6469822",
"0.6452766"... | 0.0 | -1 |
This function runs two other functions that prompt the user for input | def prompt
function = prompt_function
a, b = prompt_numbers
return a, b, function
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare_input(prompt); end",
"def another_function()\n prompt = '@#$!%'\n print \"How old are you? \"\n print prompt\n age = $stdin.gets.chomp\n print \"How tall are you? \"\n print prompt\n height = $stdin.gets.chomp\n print \"How much do you weight?\"\n puts prompt\n weight = ... | [
"0.7458676",
"0.7297848",
"0.7268164",
"0.7191035",
"0.71856666",
"0.7178354",
"0.71561",
"0.7130122",
"0.7125505",
"0.7123631",
"0.71206594",
"0.7100177",
"0.7100177",
"0.7100177",
"0.7100177",
"0.70945466",
"0.7042461",
"0.7015035",
"0.70139223",
"0.69977903",
"0.69977903",... | 0.682595 | 54 |
Add param to filters | def add_filter_param(param, value)
@mg_params[filter_param_name.to_sym][param] = value unless @mg_params[filter_param_name.to_sym].key?(param)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_filters(filters); end",
"def add_filter\n @filter = true \n end",
"def add_filter(filter)\n @filters << filter\n end",
"def add_filter(filter_symbol)\n filters << filter_symbol\n end",
"def add_filter(filter_argument = T.unsafe(nil), &filter_proc); end",
"def to_param\n \"fil... | [
"0.7667878",
"0.73295593",
"0.7155153",
"0.7059293",
"0.70547163",
"0.7017768",
"0.701622",
"0.69522434",
"0.6847494",
"0.68402976",
"0.67480344",
"0.67480344",
"0.67368716",
"0.6736221",
"0.6734661",
"0.6734661",
"0.6715528",
"0.6713427",
"0.66717345",
"0.6602613",
"0.656823... | 0.83977306 | 0 |
Get filter name by field | def get_filter_name(field, model = nil)
field_name = model.present? ? "#{model.table_name}.#{field}" : field
"#{name}[#{filter_param_name}][#{field_name}]"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_name\n if filters.one?\n filters.keys.first.to_s\n else\n filters.keys.join('_and_')\n end\n end",
"def field_name(field=nil)\n result = field_name_fragment\n result << \"[#{field}]\" if field\n result\n end",
"def field_na... | [
"0.7092277",
"0.70194924",
"0.6902115",
"0.67540735",
"0.66454047",
"0.662417",
"0.65781116",
"0.65339345",
"0.648112",
"0.6452713",
"0.63599074",
"0.6355486",
"0.6303464",
"0.6282133",
"0.6263003",
"0.61842185",
"0.61584145",
"0.6101875",
"0.61001",
"0.6095226",
"0.59746104"... | 0.85356957 | 0 |
Thinking Sphinx apply filters | def ts_apply_filters
# TODO: Make filters for Thinking Sphinx
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filters; end",
"def filters; end",
"def index \n\n ...\r\n \r\n #add/remove any selected filters\n selected_filter_conditions(Widget)\n\n @widgets = Widget.find(:all,{}, {:conditions => @conditions, :include => @included}) \n \n # This can be combined with any named scopes eg \n # @wid... | [
"0.6395649",
"0.6395649",
"0.6394962",
"0.6393056",
"0.6343207",
"0.6331165",
"0.6331165",
"0.62281",
"0.61923224",
"0.6096554",
"0.60748357",
"0.60746837",
"0.604416",
"0.60266453",
"0.60153943",
"0.6001512",
"0.5982304",
"0.597698",
"0.5964869",
"0.5903267",
"0.5897382",
... | 0.8029215 | 0 |
Following solution is optimized for time, but not space O(n) time complexity O(n) space complexity | def kth_to_last(head, k)
count = 0
current_node = head
node_hash = {}
while current_node
node_hash[count] = current_node
count += 1
current_node = current_node.next
end
node_hash[node_hash.keys.size - k].value
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solution(a)\r\n n=a.size\r\n i=1\r\n for k in a.sort do\r\n\tif k!=i \r\n\t then \r\n\t return 0\r\n\t break;\r\n\tend\r\n i+=1;\r\n end\t\r\n return 1 if a.inject(:+) ==n*(n+1)/2;\r\nend",
"def solution(m, a)\n n = a.count\n result = 0\n front = 0\n... | [
"0.72011554",
"0.68064815",
"0.6800744",
"0.6755844",
"0.6687568",
"0.66418976",
"0.6629113",
"0.6614764",
"0.66100013",
"0.6604537",
"0.65870476",
"0.6581771",
"0.65489805",
"0.65482247",
"0.6546301",
"0.6541277",
"0.65363646",
"0.65175325",
"0.6500247",
"0.6492299",
"0.6488... | 0.0 | -1 |
The following is optimized for time and space O(n) time complexity 0(1) space complexity | def kth_to_last_space_optimized(head, k)
count = 1
current_node = head
while current_node
count += 1
current_node = current_node.next
end
current_node = head
target = count - k
count = 1
while current_node
return current_node.value if count == target
count += 1
current_node = curren... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solution(a)\r\n n=a.size\r\n i=1\r\n for k in a.sort do\r\n\tif k!=i \r\n\t then \r\n\t return 0\r\n\t break;\r\n\tend\r\n i+=1;\r\n end\t\r\n return 1 if a.inject(:+) ==n*(n+1)/2;\r\nend",
"def find_dublicate(array)\n sum = 1000000*(1000000+1)/2 # (n*(n+1))... | [
"0.70928335",
"0.6901146",
"0.66407204",
"0.6599523",
"0.657768",
"0.6498791",
"0.6490742",
"0.6478487",
"0.64626044",
"0.6419806",
"0.64079374",
"0.6394649",
"0.6379443",
"0.636823",
"0.636227",
"0.6349882",
"0.63466394",
"0.63365704",
"0.6320437",
"0.63151544",
"0.63094366"... | 0.0 | -1 |
Convert CFPropertyList to binary format; since we have to count our objects we simply unique CFDictionary and CFArray | def to_str(opts={})
@unique_table = {}
@count_objects = 0
@string_size = 0
@int_size = 0
@misc_size = 0
@object_refs = 0
@written_object_count = 0
@object_table = []
@object_ref_size = 0
@offsets = []
binary_str = "bplist00"
unique_and_count_val... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_plist\n @attributes.to_plist\n end",
"def to_plist\n attributes.to_plist\n end",
"def dict_to_binary(val)\n saved_object_count = @written_object_count\n @written_object_count += 1\n\n bdata = Binary.type_bytes(\"d\",val.value.size) # d=1101, type indicator for dictionary\n... | [
"0.6139177",
"0.60764384",
"0.60576075",
"0.5864793",
"0.57980335",
"0.57768667",
"0.5773309",
"0.56523263",
"0.5488065",
"0.5468661",
"0.5372827",
"0.534327",
"0.5326962",
"0.5317539",
"0.528196",
"0.5281396",
"0.5261453",
"0.52338505",
"0.51893896",
"0.51809084",
"0.5177891... | 0.5590915 | 8 |
read a binary int value | def read_binary_int(fname,fd,length)
raise CFFormatError.new("Integer greater than 8 bytes: #{length}") if length > 3
nbytes = 1 << length
val = nil
buff = fd.read(nbytes)
case length
when 0 then
val = buff.unpack("C")
val = val[0]
when 1 then
val = b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def as_int\n return @as_int unless @as_int.nil?\n _pos = @_io.pos\n @_io.seek(0)\n @as_int = @_io.read_u2be\n @_io.seek(_pos)\n @as_int\n end",
"def read_int(offset, stream = @index)\n stream.seek(offset)\n stream.read(4).unpack('L')[0]\n end",
"def r... | [
"0.7664172",
"0.75506127",
"0.74316055",
"0.7430628",
"0.732355",
"0.72860515",
"0.72324526",
"0.715396",
"0.70769686",
"0.7073567",
"0.7015265",
"0.70132434",
"0.7009441",
"0.69623375",
"0.6928583",
"0.6905657",
"0.6901286",
"0.68502516",
"0.6789339",
"0.6773747",
"0.6761497... | 0.7823983 | 0 |
read a binary real value | def read_binary_real(fname,fd,length)
raise CFFormatError.new("Real greater than 8 bytes: #{length}") if length > 3
nbytes = 1 << length
val = nil
buff = fd.read(nbytes)
case length
when 0 then # 1 byte float? must be an error
raise CFFormatError.new("got #{length+1} byte f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def real_to_binary(val)\n bdata = Binary.type_bytes(\"2\",3) # 2 is 0010, type indicator for reals\n buff = [val].pack(\"d\")\n return bdata + buff.reverse\n end",
"def read_bignum; end",
"def binary_value\n\t\treturn self.value.unpack( 'm' ).first\n\tend",
"def read_int64; end",
"def rea... | [
"0.71810484",
"0.70387715",
"0.68851215",
"0.67749465",
"0.6718428",
"0.65083176",
"0.63742584",
"0.6350838",
"0.6321549",
"0.63113016",
"0.63111025",
"0.62680936",
"0.626058",
"0.6202346",
"0.6136513",
"0.6136513",
"0.6105215",
"0.60897",
"0.6017096",
"0.6011622",
"0.5988135... | 0.783559 | 0 |
read a binary date value | def read_binary_date(fname,fd,length)
raise CFFormatError.new("Date greater than 8 bytes: #{length}") if length > 3
nbytes = 1 << length
val = nil
buff = fd.read(nbytes)
case length
when 0 then # 1 byte CFDate is an error
raise CFFormatError.new("#{length+1} byte CFDate, er... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_date; end",
"def date_to_binary(val)\n saved_object_count = @written_object_count\n @written_object_count += 1\n\n val = val.getutc.to_f - CFDate::DATE_DIFF_APPLE_UNIX # CFDate is a real, number of seconds since 01/01/2001 00:00:00 GMT\n\n bdata = Binary.type_bytes(\"3\", 3) # 3 is 0... | [
"0.65893734",
"0.656487",
"0.65204334",
"0.64839846",
"0.63936645",
"0.6314313",
"0.5901791",
"0.57451266",
"0.5666163",
"0.562766",
"0.56220925",
"0.5616594",
"0.5577351",
"0.55132914",
"0.5490037",
"0.54841167",
"0.54658884",
"0.5410722",
"0.5404405",
"0.53968966",
"0.53851... | 0.7879995 | 0 |
Read a binary data value | def read_binary_data(fname,fd,length)
buff = "";
buff = fd.read(length) if length > 0
return CFData.new(buff,CFData::DATA_RAW)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_binary\n raise NotImplementedError\n end",
"def read_byte; end",
"def data\n read_attribute(binary ? :binary_data : :data)\n end",
"def read\n read_object(read_byte)\n end",
"def read_byte(data, offset)\n out = data[offset,1].unpack('C').first rescue 0\n return out\n end... | [
"0.7632058",
"0.73937154",
"0.73124635",
"0.72500354",
"0.7006242",
"0.69913465",
"0.69329166",
"0.6918088",
"0.68678564",
"0.6830702",
"0.6812567",
"0.6698399",
"0.6693482",
"0.6627418",
"0.66016376",
"0.6594737",
"0.6592734",
"0.65844",
"0.65458167",
"0.6540291",
"0.6513359... | 0.7130284 | 4 |
Read a binary string value | def read_binary_string(fname,fd,length)
buff = ""
buff = fd.read(length) if length > 0
@unique_table[buff] = true unless @unique_table.has_key?(buff)
return CFString.new(buff)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_string(length)\n BinData::Stringz.read(read_and_advance(length))\n end",
"def read_binary\n raise NotImplementedError\n end",
"def read(str)\n str = str.sysread(size) if not str.kind_of?(::String)\n @value = str.unpack(format).first\n size\n end",
"def binary_string; end... | [
"0.72143054",
"0.70673025",
"0.6999473",
"0.6976893",
"0.69134617",
"0.69010377",
"0.684761",
"0.6814804",
"0.679744",
"0.6681768",
"0.65348625",
"0.65180916",
"0.65180916",
"0.65172774",
"0.6513126",
"0.65090585",
"0.6474409",
"0.6444584",
"0.64056027",
"0.6397608",
"0.63882... | 0.7048001 | 2 |
Read a unicode string value, coded as UTF16BE | def read_binary_unicode_string(fname,fd,length)
# The problem is: we get the length of the string IN CHARACTERS;
# since a char in UTF-16 can be 16 or 32 bit long, we don't really know
# how long the string is in bytes
buff = fd.read(2*length)
@unique_table[buff] = true unless @unique_tab... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_string(data, offset, length, encoding)\n if \"UTF-16\".casecmp(encoding) == 0\n out = data[offset, length].unpack('v*').pack('U*')\n else\n out = data[offset, length].unpack('C*').pack('U*')\n end\n return out\n end",
"def get_utf16_of(character)\n character.encode('UTF-16BE').un... | [
"0.79713976",
"0.7114958",
"0.70792717",
"0.6842437",
"0.6825415",
"0.6810971",
"0.66008973",
"0.6565299",
"0.64788467",
"0.6384433",
"0.62750787",
"0.6213166",
"0.61774117",
"0.6167788",
"0.613427",
"0.6095045",
"0.60800445",
"0.6056757",
"0.60370576",
"0.6020688",
"0.600382... | 0.71791196 | 1 |
Read an binary array value, including contained objects | def read_binary_array(fname,fd,length)
ary = []
# first: read object refs
if(length != 0) then
buff = fd.read(length * @object_ref_size)
objects = buff.unpack(@object_ref_size == 1 ? "C*" : "n*")
# now: read objects
0.upto(length-1) do |i|
object = read_bina... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_binary_object(fname,fd)\n # first: read the marker byte\n buff = fd.read(1)\n\n object_length = buff.unpack(\"C*\")\n object_length = object_length[0] & 0xF\n\n buff = buff.unpack(\"H*\")\n object_type = buff[0][0].chr\n\n if(object_type != \"0\" && object_length == 15)... | [
"0.70284456",
"0.69862336",
"0.68214107",
"0.6640798",
"0.6626206",
"0.65283865",
"0.6451477",
"0.64165217",
"0.63352776",
"0.6239434",
"0.6229584",
"0.62125087",
"0.6182966",
"0.61515546",
"0.6077128",
"0.6076064",
"0.6062472",
"0.6019979",
"0.59944135",
"0.59940684",
"0.598... | 0.71458286 | 0 |
Read a dictionary value, including contained objects | def read_binary_dict(fname,fd,length)
dict = {}
# first: read keys
if(length != 0) then
buff = fd.read(length * @object_ref_size)
keys = buff.unpack(@object_ref_size == 1 ? "C*" : "n*")
# second: read object refs
buff = fd.read(length * @object_ref_size)
objec... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read\n value = super\n value = value.to_hash if value.respond_to?(:to_hash)\n value\n end",
"def extract_data(object)\n if object.is_a?(Hash) && object.size == 1\n return object.values.first\n else\n return object\n end\n end",
"def read_entry(key, **op... | [
"0.6401827",
"0.62023777",
"0.60165054",
"0.60061866",
"0.59796745",
"0.59665734",
"0.5922959",
"0.5887369",
"0.5864625",
"0.5849955",
"0.5823342",
"0.5818345",
"0.58171487",
"0.5755363",
"0.5720155",
"0.5680275",
"0.5632676",
"0.5576335",
"0.5573226",
"0.55635834",
"0.554881... | 0.59418935 | 6 |
Read an object type byte, decode it and delegate to the correct reader function | def read_binary_object(fname,fd)
# first: read the marker byte
buff = fd.read(1)
object_length = buff.unpack("C*")
object_length = object_length[0] & 0xF
buff = buff.unpack("H*")
object_type = buff[0][0].chr
if(object_type != "0" && object_length == 15) then
object_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read\n read_object(read_byte)\n end",
"def recover_object\n # Up to the tab is the amount of bytes to read\n demarshal_bytes = @io.gets(\"\\t\").to_i\n \n # When at end of IO return nil\n raise NothingToRecover if demarshal_bytes.zero?\n \n blob = @io.read(demarshal_bytes)\n d... | [
"0.7598876",
"0.6863633",
"0.6685689",
"0.66833586",
"0.65031505",
"0.64321953",
"0.64161086",
"0.63541293",
"0.6300766",
"0.6239332",
"0.62110823",
"0.6168578",
"0.61405313",
"0.6116484",
"0.60989505",
"0.6098249",
"0.6062003",
"0.5992228",
"0.5992228",
"0.59890467",
"0.5972... | 0.7098113 | 1 |
Read an object type byte at position $pos, decode it and delegate to the correct reader function | def read_binary_object_at(fname,fd,pos)
position = @offsets[pos]
fd.seek(position,IO::SEEK_SET)
return read_binary_object(fname,fd)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read\n read_object(read_byte)\n end",
"def read_binary_object(fname,fd)\n # first: read the marker byte\n buff = fd.read(1)\n\n object_length = buff.unpack(\"C*\")\n object_length = object_length[0] & 0xF\n\n buff = buff.unpack(\"H*\")\n object_type = buff[0][0].chr\n\n... | [
"0.7311331",
"0.6798551",
"0.6503346",
"0.6390284",
"0.6339939",
"0.6306967",
"0.62698436",
"0.61795175",
"0.61770576",
"0.6116316",
"0.60945594",
"0.60597056",
"0.600354",
"0.6000059",
"0.5911306",
"0.59051025",
"0.58754176",
"0.58548117",
"0.5845684",
"0.5837417",
"0.582976... | 0.6630583 | 2 |
Uniques and transforms a string value to binary format and adds it to the object table | def string_to_binary(val)
saved_object_count = -1
unless(@unique_table.has_key?(val)) then
saved_object_count = @written_object_count
@written_object_count += 1
@unique_table[val] = saved_object_count
utf16 = false
val.each_byte do |b|
if(b > 127) then
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_to_binary(val)\n saved_object_count = @written_object_count\n @written_object_count += 1\n\n bdata = Binary.type_bytes(\"4\", val.bytesize) # a is 1000, type indicator for data\n @object_table[saved_object_count] = bdata + val\n\n return saved_object_count\n end",
"def cast(v... | [
"0.6002326",
"0.5797143",
"0.5793277",
"0.56514406",
"0.561846",
"0.5611824",
"0.5598785",
"0.55561554",
"0.55302864",
"0.55093014",
"0.5441502",
"0.54117167",
"0.5360556",
"0.5351907",
"0.53468585",
"0.5341088",
"0.5316499",
"0.53156316",
"0.5307022",
"0.5254363",
"0.5234028... | 0.7459094 | 0 |
Codes an integer to binary format | def int_to_binary(value)
nbytes = 0
nbytes = 1 if value > 0xFF # 1 byte integer
nbytes += 1 if value > 0xFFFF # 4 byte integer
nbytes += 1 if value > 0xFFFFFFFF # 8 byte integer
nbytes = 3 if value < 0 # 8 byte integer, since signed
bdata = Binary.type_bytes("1", nbytes) # 1 is 0001... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def int_to_binary_string(number)\n number.to_s(2)\nend",
"def to_bin(number)\n number = Integer(number);\n if(number == 0)\n return 0;\n end\n ret_bin = \"\";\n ## Untill val is zero, convert it into binary format\n while(number != 0)\n ret_bin = String(number % 2) + ret_bi... | [
"0.8118605",
"0.7725005",
"0.7348912",
"0.7309225",
"0.7218738",
"0.7218738",
"0.7111606",
"0.7067939",
"0.6997278",
"0.6994265",
"0.69752103",
"0.6933819",
"0.6928739",
"0.69271845",
"0.692328",
"0.6913677",
"0.6881685",
"0.68341064",
"0.68309563",
"0.68174404",
"0.6761772",... | 0.7988794 | 1 |
Codes a real value to binary format | def real_to_binary(val)
bdata = Binary.type_bytes("2",3) # 2 is 0010, type indicator for reals
buff = [val].pack("d")
return bdata + buff.reverse
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def value_to_binary_string(value)\n #value.pack(\"V\")\n raise NotImplementedError\n end",
"def input_to_bitstring( value )\r\n value\r\n end",
"def to_binary()\n return self.unpack('B*').join\n end",
"def show_binstring()\n @values.values.map do |v|\n v... | [
"0.76387566",
"0.73857784",
"0.70741576",
"0.69966084",
"0.69353193",
"0.6870486",
"0.686756",
"0.6860697",
"0.68493295",
"0.6845571",
"0.68288904",
"0.6777516",
"0.6741485",
"0.67203945",
"0.6716213",
"0.6709726",
"0.6709726",
"0.6681656",
"0.66692364",
"0.6667497",
"0.66251... | 0.8134485 | 0 |
Converts a numeric value to binary and adds it to the object table | def num_to_binary(value)
saved_object_count = @written_object_count
@written_object_count += 1
val = ""
if(value.is_a?(CFInteger)) then
val = int_to_binary(value.value)
else
val = real_to_binary(value.value)
end
@object_table[saved_object_count] = val
re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_to_binary(val)\n saved_object_count = @written_object_count\n @written_object_count += 1\n\n bdata = Binary.type_bytes(\"4\", val.bytesize) # a is 1000, type indicator for data\n @object_table[saved_object_count] = bdata + val\n\n return saved_object_count\n end",
"def dict_t... | [
"0.7372401",
"0.6532221",
"0.6515368",
"0.6515368",
"0.64618844",
"0.6447378",
"0.63010615",
"0.6284817",
"0.6267158",
"0.6241623",
"0.6154173",
"0.60950464",
"0.60596514",
"0.60448486",
"0.603212",
"0.60292953",
"0.60069513",
"0.5987567",
"0.589815",
"0.58818686",
"0.5877616... | 0.7999949 | 0 |
Convert date value (apple format) to binary and adds it to the object table | def date_to_binary(val)
saved_object_count = @written_object_count
@written_object_count += 1
val = val.getutc.to_f - CFDate::DATE_DIFF_APPLE_UNIX # CFDate is a real, number of seconds since 01/01/2001 00:00:00 GMT
bdata = Binary.type_bytes("3", 3) # 3 is 0011, type indicator for date
@o... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_date()\n #This is a stub, used for indexing\n end",
"def data_to_binary(val)\n saved_object_count = @written_object_count\n @written_object_count += 1\n\n bdata = Binary.type_bytes(\"4\", val.bytesize) # a is 1000, type indicator for data\n @object_table[saved_object_count] =... | [
"0.62352306",
"0.6061859",
"0.5925008",
"0.59146583",
"0.5899505",
"0.58940595",
"0.5834136",
"0.5696109",
"0.56730443",
"0.5643133",
"0.56275725",
"0.5623474",
"0.56228405",
"0.56044054",
"0.5595214",
"0.55874425",
"0.55853236",
"0.55780107",
"0.55737776",
"0.5545583",
"0.55... | 0.80985737 | 0 |
Convert a bool value to binary and add it to the object table | def bool_to_binary(val)
saved_object_count = @written_object_count
@written_object_count += 1
@object_table[saved_object_count] = val ? "\x9" : "\x8" # 0x9 is 1001, type indicator for true; 0x8 is 1000, type indicator for false
return saved_object_count
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_boo string\n\t\tActiveRecord::Type::Boolean.new.cast(string)\n\tend",
"def old_boolean_to_binary(arr)\n binary = \"\"\n\n arr.each do |boolean|\n if boolean\n binary += \"1\"\n else\n binary += \"0\"\n end\n end\n\n binary\nend",
"def boolean_to_binary(array)\nend",
"def write_b... | [
"0.72672784",
"0.7210135",
"0.7078653",
"0.6999839",
"0.699487",
"0.66359603",
"0.6601401",
"0.6562944",
"0.6548674",
"0.65412736",
"0.65098464",
"0.640848",
"0.6400983",
"0.6390524",
"0.63897985",
"0.63661003",
"0.63559127",
"0.6315174",
"0.6306795",
"0.629747",
"0.62785494"... | 0.8388247 | 0 |
Convert data value to binary format and add it to the object table | def data_to_binary(val)
saved_object_count = @written_object_count
@written_object_count += 1
bdata = Binary.type_bytes("4", val.bytesize) # a is 1000, type indicator for data
@object_table[saved_object_count] = bdata + val
return saved_object_count
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_binary\n Formatters::Binary.new.serialize self\n end",
"def dict_to_binary(val)\n saved_object_count = @written_object_count\n @written_object_count += 1\n\n bdata = Binary.type_bytes(\"d\",val.value.size) # d=1101, type indicator for dictionary\n\n val.value.each_key do |k... | [
"0.6759858",
"0.67387134",
"0.6717039",
"0.66537166",
"0.66537064",
"0.66328",
"0.66024834",
"0.6579127",
"0.62942713",
"0.61972284",
"0.61822",
"0.6161647",
"0.6134418",
"0.6081542",
"0.60703397",
"0.6036884",
"0.59574085",
"0.5957148",
"0.5904086",
"0.5901617",
"0.5884673",... | 0.80280674 | 0 |
Convert array to binary format and add it to the object table | def array_to_binary(val)
saved_object_count = @written_object_count
@written_object_count += 1
bdata = Binary.type_bytes("a", val.value.size) # a is 1010, type indicator for arrays
val.value.each do |v|
bdata += Binary.pack_it_with_size(@object_ref_size, v.to_binary(self));
end
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_to_binary(val)\n saved_object_count = @written_object_count\n @written_object_count += 1\n\n bdata = Binary.type_bytes(\"4\", val.bytesize) # a is 1000, type indicator for data\n @object_table[saved_object_count] = bdata + val\n\n return saved_object_count\n end",
"def to_bin... | [
"0.6767909",
"0.64879626",
"0.6384719",
"0.6267628",
"0.62673205",
"0.6246435",
"0.61951655",
"0.6126787",
"0.60429925",
"0.6011801",
"0.5992629",
"0.5983729",
"0.59797907",
"0.59782565",
"0.59502876",
"0.58508396",
"0.5833801",
"0.5829443",
"0.5804415",
"0.5770621",
"0.57706... | 0.7604434 | 0 |
Convert dictionary to binary format and add it to the object table | def dict_to_binary(val)
saved_object_count = @written_object_count
@written_object_count += 1
bdata = Binary.type_bytes("d",val.value.size) # d=1101, type indicator for dictionary
val.value.each_key do |k|
str = CFString.new(k)
key = str.to_binary(self)
bdata += Binary.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def marshal_dump\n @table\n end",
"def to_binary\n Formatters::Binary.new.serialize self\n end",
"def data_to_binary(val)\n saved_object_count = @written_object_count\n @written_object_count += 1\n\n bdata = Binary.type_bytes(\"4\", val.bytesize) # a is 1000, type indicator for d... | [
"0.6019073",
"0.6013988",
"0.59561574",
"0.58213556",
"0.5737301",
"0.5699765",
"0.56747013",
"0.5618138",
"0.5615141",
"0.55964977",
"0.55716604",
"0.5534259",
"0.55316526",
"0.5496958",
"0.54798055",
"0.54774326",
"0.5458964",
"0.54547024",
"0.5425382",
"0.54219854",
"0.533... | 0.7461467 | 0 |
Create a static hop BFD peer Creates a BFD peer for static route. The required parameters includes peer IP address. | def create_static_hop_bfd_peer(logical_router_id, static_hop_bfd_peer, opts = {})
data, _status_code, _headers = create_static_hop_bfd_peer_with_http_info(logical_router_id, static_hop_bfd_peer, opts)
data
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_static_hop_bfd_peer_with_http_info(logical_router_id, static_hop_bfd_peer, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: ManagementPlaneApiLogicalRoutingAndServicesBfdPeersApi.create_static_hop_bfd_peer ...'\n end\n # verify the requir... | [
"0.6617239",
"0.6229633",
"0.60930145",
"0.5871882",
"0.57874286",
"0.5786859",
"0.5782089",
"0.5502796",
"0.5379553",
"0.5352684",
"0.534905",
"0.5237958",
"0.5224783",
"0.5205536",
"0.51922005",
"0.51922005",
"0.509461",
"0.5091298",
"0.50749326",
"0.5036021",
"0.4987679",
... | 0.79299843 | 0 |
Create a static hop BFD peer Creates a BFD peer for static route. The required parameters includes peer IP address. | def create_static_hop_bfd_peer_with_http_info(logical_router_id, static_hop_bfd_peer, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: ManagementPlaneApiLogicalRoutingAndServicesBfdPeersApi.create_static_hop_bfd_peer ...'
end
# verify the required parame... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_static_hop_bfd_peer(logical_router_id, static_hop_bfd_peer, opts = {})\n data, _status_code, _headers = create_static_hop_bfd_peer_with_http_info(logical_router_id, static_hop_bfd_peer, opts)\n data\n end",
"def update_static_hop_bfd_peer(logical_router_id, bfd_peer_id, static_hop_bfd_pee... | [
"0.7930343",
"0.62298757",
"0.6094754",
"0.587161",
"0.5788293",
"0.5787778",
"0.57824856",
"0.5504895",
"0.5381322",
"0.53558946",
"0.5350371",
"0.5236187",
"0.52263016",
"0.5206584",
"0.51940227",
"0.51940227",
"0.5095933",
"0.50930303",
"0.5076193",
"0.5038284",
"0.4989422... | 0.6618446 | 1 |
Delete a specified static route BFD peer cofigured on a specified logical router Deletes the specified BFD peer present on specified logical router. | def delete_static_hop_bfd_peer(logical_router_id, bfd_peer_id, opts = {})
delete_static_hop_bfd_peer_with_http_info(logical_router_id, bfd_peer_id, opts)
nil
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_static_hop_bfd_peer_with_http_info(logical_router_id, bfd_peer_id, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: ManagementPlaneApiLogicalRoutingAndServicesBfdPeersApi.delete_static_hop_bfd_peer ...'\n end\n # verify the required param... | [
"0.67823887",
"0.6534451",
"0.6495973",
"0.64280313",
"0.6255645",
"0.5999183",
"0.59921753",
"0.5791187",
"0.5701881",
"0.56482565",
"0.5554026",
"0.5551079",
"0.5528091",
"0.5514554",
"0.5485993",
"0.54585177",
"0.5414058",
"0.5398831",
"0.5361642",
"0.5350564",
"0.53363323... | 0.82927024 | 0 |
Delete a specified static route BFD peer cofigured on a specified logical router Deletes the specified BFD peer present on specified logical router. | def delete_static_hop_bfd_peer_with_http_info(logical_router_id, bfd_peer_id, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: ManagementPlaneApiLogicalRoutingAndServicesBfdPeersApi.delete_static_hop_bfd_peer ...'
end
# verify the required parameter 'log... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_static_hop_bfd_peer(logical_router_id, bfd_peer_id, opts = {})\n delete_static_hop_bfd_peer_with_http_info(logical_router_id, bfd_peer_id, opts)\n nil\n end",
"def delete_static_route(logical_router_id, id, opts = {})\n delete_static_route_with_http_info(logical_router_id, id, opts)\... | [
"0.82927585",
"0.6535487",
"0.649687",
"0.64274323",
"0.62566966",
"0.6000363",
"0.59927255",
"0.57916",
"0.5702532",
"0.5646954",
"0.55535996",
"0.5549381",
"0.5527597",
"0.5515386",
"0.54870594",
"0.54595447",
"0.5413791",
"0.5399849",
"0.53616154",
"0.5349558",
"0.533597",... | 0.6781829 | 1 |
List static routes BFD Peers Returns information about all BFD peers created on specified logical router for static routes. | def list_static_hop_bfd_peers(logical_router_id, opts = {})
data, _status_code, _headers = list_static_hop_bfd_peers_with_http_info(logical_router_id, opts)
data
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_static_routes(logical_router_id, opts = {})\n data, _status_code, _headers = list_static_routes_with_http_info(logical_router_id, opts)\n data\n end",
"def list_static_hop_bfd_peers_with_http_info(logical_router_id, opts = {})\n if @api_client.config.debugging\n @api_client.conf... | [
"0.6381591",
"0.5682232",
"0.56553996",
"0.5518457",
"0.5518457",
"0.5495218",
"0.547126",
"0.5423009",
"0.54211867",
"0.5328362",
"0.532435",
"0.52953637",
"0.52602637",
"0.5161609",
"0.5137966",
"0.5121958",
"0.512092",
"0.5114098",
"0.51108235",
"0.50975984",
"0.5093997",
... | 0.72717303 | 0 |
List static routes BFD Peers Returns information about all BFD peers created on specified logical router for static routes. | def list_static_hop_bfd_peers_with_http_info(logical_router_id, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: ManagementPlaneApiLogicalRoutingAndServicesBfdPeersApi.list_static_hop_bfd_peers ...'
end
# verify the required parameter 'logical_router_id'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_static_hop_bfd_peers(logical_router_id, opts = {})\n data, _status_code, _headers = list_static_hop_bfd_peers_with_http_info(logical_router_id, opts)\n data\n end",
"def list_static_routes(logical_router_id, opts = {})\n data, _status_code, _headers = list_static_routes_with_http_info(... | [
"0.72717154",
"0.63821566",
"0.5654464",
"0.55182755",
"0.55182755",
"0.5495078",
"0.5472782",
"0.5420841",
"0.54201937",
"0.5327967",
"0.5324518",
"0.5295144",
"0.5260151",
"0.5161899",
"0.5136402",
"0.5120511",
"0.51203746",
"0.5113525",
"0.5110664",
"0.5096531",
"0.5094369... | 0.56827587 | 2 |
Read a static route BFD peer Read the BFD peer having specified ID. | def read_static_hop_bfd_peer(logical_router_id, bfd_peer_id, opts = {})
data, _status_code, _headers = read_static_hop_bfd_peer_with_http_info(logical_router_id, bfd_peer_id, opts)
data
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_static_route(logical_router_id, id, opts = {})\n data, _status_code, _headers = read_static_route_with_http_info(logical_router_id, id, opts)\n data\n end",
"def read_static_hop_bfd_peer_with_http_info(logical_router_id, bfd_peer_id, opts = {})\n if @api_client.config.debugging\n ... | [
"0.6606323",
"0.6104351",
"0.5968783",
"0.5813354",
"0.5699982",
"0.5678284",
"0.56629646",
"0.56325006",
"0.5626648",
"0.54887843",
"0.5481124",
"0.53925824",
"0.5363777",
"0.5340827",
"0.52619636",
"0.5257866",
"0.5216754",
"0.521414",
"0.5208699",
"0.5193338",
"0.5193304",... | 0.69173354 | 0 |
Read a static route BFD peer Read the BFD peer having specified ID. | def read_static_hop_bfd_peer_with_http_info(logical_router_id, bfd_peer_id, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: ManagementPlaneApiLogicalRoutingAndServicesBfdPeersApi.read_static_hop_bfd_peer ...'
end
# verify the required parameter 'logical... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_static_hop_bfd_peer(logical_router_id, bfd_peer_id, opts = {})\n data, _status_code, _headers = read_static_hop_bfd_peer_with_http_info(logical_router_id, bfd_peer_id, opts)\n data\n end",
"def read_static_route(logical_router_id, id, opts = {})\n data, _status_code, _headers = read_st... | [
"0.6917232",
"0.6608929",
"0.59693867",
"0.5812565",
"0.5699138",
"0.56788343",
"0.56645817",
"0.56325674",
"0.56258357",
"0.5488818",
"0.54817367",
"0.5394265",
"0.5364146",
"0.5341863",
"0.52623606",
"0.52566415",
"0.52169806",
"0.52130526",
"0.52111435",
"0.5193842",
"0.51... | 0.6103767 | 2 |
Update a static route BFD peer Modifies the static route BFD peer. Modifiable parameters includes peer IP, enable flag and configuration of the BFD peer. | def update_static_hop_bfd_peer(logical_router_id, bfd_peer_id, static_hop_bfd_peer, opts = {})
data, _status_code, _headers = update_static_hop_bfd_peer_with_http_info(logical_router_id, bfd_peer_id, static_hop_bfd_peer, opts)
data
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_static_hop_bfd_peer_with_http_info(logical_router_id, bfd_peer_id, static_hop_bfd_peer, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: ManagementPlaneApiLogicalRoutingAndServicesBfdPeersApi.update_static_hop_bfd_peer ...'\n end\n # veri... | [
"0.6365141",
"0.55864155",
"0.55398107",
"0.54104346",
"0.5408062",
"0.52611494",
"0.52549493",
"0.52203995",
"0.521008",
"0.52073044",
"0.5157824",
"0.5157343",
"0.51220965",
"0.5112575",
"0.5112575",
"0.5034793",
"0.5000252",
"0.4960514",
"0.4959216",
"0.4952912",
"0.493463... | 0.70052713 | 0 |
Update a static route BFD peer Modifies the static route BFD peer. Modifiable parameters includes peer IP, enable flag and configuration of the BFD peer. | def update_static_hop_bfd_peer_with_http_info(logical_router_id, bfd_peer_id, static_hop_bfd_peer, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: ManagementPlaneApiLogicalRoutingAndServicesBfdPeersApi.update_static_hop_bfd_peer ...'
end
# verify the re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_static_hop_bfd_peer(logical_router_id, bfd_peer_id, static_hop_bfd_peer, opts = {})\n data, _status_code, _headers = update_static_hop_bfd_peer_with_http_info(logical_router_id, bfd_peer_id, static_hop_bfd_peer, opts)\n data\n end",
"def update_static_route(logical_router_id, id, static_r... | [
"0.70053154",
"0.55831844",
"0.55385983",
"0.54096377",
"0.5407031",
"0.5260514",
"0.5256426",
"0.5219717",
"0.5211384",
"0.52049154",
"0.51588905",
"0.5158409",
"0.5121474",
"0.5113762",
"0.5113762",
"0.50361305",
"0.4999628",
"0.49626377",
"0.49598977",
"0.4952247",
"0.4935... | 0.63649476 | 1 |
show all the bookings on booking_history | def booking_history
@bookings = Booking.where(:user_id => current_user.id).paginate(:page => params[:page], :per_page => 10)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_booking_history\n @booking_history = BookingHistory.find(params[:id])\n end",
"def index\n @bookings = Booking.all\n end",
"def index\n @bookings = Booking.order(updated_at: :desc).page(params[:page]).per(NUM_PER_PAGE)\n end",
"def index\n @bookings = Booking.all\n end",
"de... | [
"0.75333446",
"0.7191425",
"0.71350545",
"0.7134303",
"0.7134303",
"0.7134303",
"0.7134303",
"0.7134303",
"0.7134303",
"0.7134303",
"0.7134303",
"0.7134303",
"0.7134303",
"0.7134303",
"0.7134303",
"0.7134303",
"0.7123582",
"0.6983818",
"0.69792986",
"0.6926872",
"0.6871498",
... | 0.82227737 | 0 |
allocate taxi within range for booking | def booking_texi(vehicle_type_id, pickup_date, pickup_time, dropoff_date, dropoff_time, pickup_addr)
@texi_info = TexiInfo.near(pickup_addr,4).where(vehicle_type_id: vehicle_type_id).map(&:id).uniq rescue 0
@bookings = Booking.where(:user_id => current_user.id).where('pickup_time <= ? AND dropoff_time >= ?', pi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_tax_charge!\n #puts \"Adjustments #{adjustments} TAX #{tax_total}\"\n #puts \"CREATE TAX for #{ship_address} \"\n all_rates = Spree::TaxRate.all\n matching_rates = all_rates.select { |rate| rate.zone.include?(ship_address) }\n if matching_rates.empty?\n matching_rates = all_rates.se... | [
"0.5994364",
"0.5947343",
"0.59292084",
"0.5676179",
"0.5608662",
"0.55748254",
"0.55671656",
"0.5541891",
"0.5539141",
"0.5490904",
"0.5461911",
"0.54490584",
"0.54376036",
"0.54068834",
"0.53668654",
"0.5360255",
"0.5356661",
"0.53511155",
"0.5331436",
"0.5314998",
"0.53029... | 0.5163432 | 45 |
show pick_up and drop_off address on new booking map | def show_new_booking_map
@pickup_address = Geocoder.search(params[:pick_up_addr]).first
@dropoff_address = Geocoder.search(params[:drop_off_addr]).first
@hash = Gmaps4rails.build_markers(@pickup_address) do |user, marker|
marker.lat user.latitude
marker.lng user.longitude
marker.infowindow "PickU... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def showpickup_address(booking_id)\n pa = PickupAddress.where(:booking_id => booking_id).last\n pa.address rescue \"\"\n end",
"def showdropoff_address(booking_id)\n pa = DropoffAddress.where(:booking_id => booking_id).last\n pa.address rescue \"\"\n end",
"def get_address\n booking = Booking.... | [
"0.67744863",
"0.65876126",
"0.65671104",
"0.63637066",
"0.6055136",
"0.6049782",
"0.60411626",
"0.59734213",
"0.594067",
"0.5938259",
"0.59177",
"0.59027946",
"0.5878054",
"0.5865389",
"0.5864325",
"0.58348703",
"0.57920045",
"0.57724124",
"0.57297826",
"0.57114345",
"0.5703... | 0.63521314 | 4 |
recurrent pick_up and drop_off address | def get_address
booking = Booking.where(user_id: current_user.id).last
pick_up_addr = PickupAddress.where(:booking_id => booking.id).last
drop_off_addr = DropoffAddress.where(:booking_id => booking.id).last
hash = {:pick_up_addr => pick_up_addr.address, :drop_off_addr => drop_off_addr.address}
respo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_drop_off\n @bus1.pick_up(@person)\n assert_equal(1, @bus1.number_passengers())\n @bus1.drop_off(@person)\n assert_equal(0, @bus1.number_passengers())\n end",
"def preselect_existing_address\n return unless can_preselect_address?\n\n selected_address = temp_addresses.detect { |addr... | [
"0.59913915",
"0.54354763",
"0.5411594",
"0.5289057",
"0.52543163",
"0.5247747",
"0.5221226",
"0.51953673",
"0.5114895",
"0.51058376",
"0.5054755",
"0.5032971",
"0.5032971",
"0.5018826",
"0.49849388",
"0.4968024",
"0.4968024",
"0.49610198",
"0.49473",
"0.49436817",
"0.4920519... | 0.0 | -1 |
handling booking parameters of booking tab | def booking_params
params[:booking][:user_id] = current_user.id
vehicle_type_id = params[:booking][:vehicle_preferences_attributes].first[1][:vehicle_type_id]
pickup_date = params[:booking][:pickup_datetime]
pickup_time = params[:booking][:pickup_time]
dropoff_date = params[:booking][:return_pickup_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def booking_params\n params[:booking]\n end",
"def booking_params\n if ['index', 'destroy'].include?(params[:action])\n params.permit(:booking)\n else\n params.require(:booking).permit(:date_in, :date_out, :hotel_id,:user_id,:status)\n end\n\n end",
"def show... | [
"0.7540592",
"0.72203285",
"0.7195991",
"0.7069011",
"0.7047531",
"0.7029437",
"0.70106757",
"0.69961333",
"0.6982345",
"0.6970114",
"0.6962022",
"0.69605994",
"0.6954737",
"0.6951022",
"0.6935218",
"0.69285244",
"0.69266385",
"0.69034845",
"0.6886282",
"0.68806916",
"0.68758... | 0.68247545 | 26 |
GET /plants/1 GET /plants/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n \n @plants = Plant.all\n @personal_plants = PersonalPlant.where(:user_id => session[:user][:id])\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @plants }\n end\n end",
"def index\n @plants = Plant.all\n\n respond_to do |format|\n... | [
"0.7626426",
"0.7559377",
"0.7494183",
"0.69456923",
"0.67404145",
"0.6738881",
"0.6736135",
"0.6680127",
"0.6663009",
"0.6593484",
"0.65574867",
"0.64715606",
"0.64597154",
"0.6404637",
"0.63969845",
"0.6395302",
"0.6357955",
"0.632299",
"0.6296218",
"0.6293668",
"0.6291755"... | 0.0 | -1 |
POST /plants POST /plants.json | def create
@plant = @garden.plants.new(plant_params)
respond_to do |format|
if @plant.save
format.html { redirect_to garden_plant_path(@garden, @plant), notice: 'Plant was successfully created.' }
format.json { render action: 'show', status: :created, location: @plant }
else
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n plant = Plant.create(plant_params)\n render json: plant, status: :created\n end",
"def create\n @plant = current_user.plants.create(plant_params)\n if @plant.valid?\n redirect_to plant_path(@plant)\n else\n render :new, status: :unprocessable_entity\n end\n end",
"def... | [
"0.6902806",
"0.6719342",
"0.64493144",
"0.61954564",
"0.6145679",
"0.6139447",
"0.61214685",
"0.60941553",
"0.6040986",
"0.6024834",
"0.60134804",
"0.595717",
"0.5945627",
"0.59392214",
"0.5935888",
"0.5934618",
"0.58955294",
"0.58821785",
"0.5847297",
"0.58405566",
"0.58387... | 0.68420595 | 1 |
PATCH/PUT /plants/1 PATCH/PUT /plants/1.json | def update
respond_to do |format|
if @plant.update(plant_params)
format.html { redirect_to garden_plant_path(@garden, @plant), notice: 'Plant was successfully updated.' }
format.json { head :no_content }
else
format.html { render action: 'edit' }
format.json { render json... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patch!\n request! :patch\n end",
"def update\n if not check_logged_in then\n return\n end\n\n @plant = Plant.find(params[:id])\n\n respond_to do |format|\n if @plant.update_attributes(params[:plant])\n format.html { redirect_to @plant, notice: 'Plant was successfully updated.... | [
"0.6417405",
"0.63763666",
"0.6347557",
"0.6264377",
"0.62427336",
"0.6241535",
"0.62391424",
"0.623645",
"0.6227365",
"0.6192443",
"0.6180778",
"0.6176146",
"0.6170411",
"0.61692363",
"0.61692363",
"0.61692363",
"0.61605185",
"0.615469",
"0.6097303",
"0.6097303",
"0.6093931"... | 0.6388268 | 1 |
DELETE /plants/1 DELETE /plants/1.json | def destroy
@plant = @garden.plants.find(params[:id])
@plant.destroy
respond_to do |format|
format.html { redirect_to @garden, notice: 'Plant deleted.' }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n if not check_logged_in then\n return\n end\n @plant = Plant.find(params[:id])\n @plant.destroy\n\n respond_to do |format|\n format.html { redirect_to plants_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n if not check_logged_in then\n ... | [
"0.7304276",
"0.72435623",
"0.7090649",
"0.70646024",
"0.7037072",
"0.7020316",
"0.69914526",
"0.6966658",
"0.6936882",
"0.68521255",
"0.6838",
"0.68047786",
"0.67268914",
"0.6722232",
"0.6717373",
"0.6710692",
"0.6681807",
"0.6676933",
"0.6676933",
"0.66657996",
"0.66657",
... | 0.75170726 | 0 |
Use callbacks to share common setup or constraints between actions. | def set_garden
@garden = Garden.find(params[:garden_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 plant_params
params.require(:plant).permit(:garden_id, :plant_image, :family, :variety, :seed_source, :quantity, :notes, :plant_date)
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.6978086",
"0.6780264",
"0.6742658",
"0.6738813",
"0.67338693",
"0.65908474",
"0.6501793",
"0.6495506",
"0.64796513",
"0.64755446",
"0.6454826",
"0.6437561",
"0.6377127",
"0.63722163",
"0.6364058",
"0.63178706",
"0.62979764",
"0.62968165",
"0.62913024",
"0.6289789",
"0.6289... | 0.0 | -1 |
This method will allow me to check the password attempt A new password object will be created(but not saved) comparing the current password_digest to the pasword attempt's digest | def is_password?(password_attempt)
BCrypt::Password.new(password_digest).is_password?(password_attempt)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def auth_pass(password)\n BCrypt::Password.create(password) == self.hash_pass\n end",
"def validate_password(challenge)\n actual = BCrypt::Password.new(password_digest)\n actual == challenge\n end",
"def is_password?(password_attempt)\n BCrypt::Password.new(password_digest).is_password?(password_... | [
"0.73229575",
"0.7279151",
"0.7199799",
"0.7168252",
"0.71405554",
"0.71181184",
"0.706325",
"0.706325",
"0.7051116",
"0.6977497",
"0.69660085",
"0.6958755",
"0.69585586",
"0.6944173",
"0.69436115",
"0.6935888",
"0.693142",
"0.6917615",
"0.6857313",
"0.6857313",
"0.6825218",
... | 0.7249801 | 2 |
The equal sign next to password will allow us to set a password value directly instead of having to pass it as a parameter Self within the method refers to every instance of a user | def password=(password)
@password = password
self.password_digest = BCrypt::Password.create(password)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def password=(password)\n @password = password\n end",
"def password=(new_password); end",
"def set_password_field(password)\n end",
"def password=(should); end",
"def set_password(pass)\n self.user_password = User.crypt(pass)\n end",
"def password=(value)\n @password = value\n... | [
"0.7945201",
"0.7936429",
"0.7911718",
"0.7854132",
"0.78001887",
"0.77896094",
"0.7750377",
"0.77147377",
"0.76700145",
"0.7643079",
"0.7639849",
"0.7629075",
"0.76205117",
"0.76205117",
"0.76205117",
"0.76205117",
"0.762029",
"0.7552042",
"0.75517905",
"0.7536476",
"0.75313... | 0.0 | -1 |
The list of all updatable properties | def updatable_properties
@updatable ||= Set.new
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_fields\n fieldlist = self.class.required_on_update + @newvalues.to_a - self.class.never_on_update\n @properties.select{|key, value| fieldlist.include?(key)}\n end",
"def modified_properties\n return @modified_properties\n end",
"def updatable_property name, *ar... | [
"0.67452586",
"0.6656477",
"0.64379704",
"0.6398018",
"0.62315035",
"0.6193906",
"0.61785704",
"0.61513007",
"0.61110914",
"0.6100965",
"0.6099039",
"0.60753393",
"0.6023469",
"0.6021993",
"0.5992287",
"0.59601694",
"0.59458965",
"0.5933607",
"0.5912656",
"0.58987504",
"0.588... | 0.8273149 | 0 |
Add a new updatable property | def updatable_property name, *args
property name, *args
@updatable ||= Set.new
@updatable << name
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updatable_properties\n @updatable ||= Set.new\n end",
"def add_property(key, value = nil, column_properties = {})\n key = key.to_sym\n unless property? key\n @_values[key] = value\n\n # Include in database columns definition\n @_columns[key] = {} unless column... | [
"0.6705231",
"0.6028638",
"0.60149807",
"0.60097134",
"0.59517425",
"0.5933048",
"0.59043676",
"0.58887565",
"0.5829095",
"0.5828522",
"0.58160406",
"0.57781696",
"0.57781696",
"0.57398236",
"0.57256514",
"0.5691363",
"0.56197745",
"0.55551666",
"0.55349386",
"0.55204296",
"0... | 0.7993935 | 0 |
GET /comments GET /comments.json | def index
@comments = Comment.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def comments\n client.get(\"/#{id}/comments\")\n end",
"def comments\n @list.client.get(\"#{url}/comments\")\n end",
"def comments\n @list.client.get(\"#{url}/comments\")\n end",
"def comments\n render json: @post.comments\n end",
"def list\n comments = Comment.where(post: @p... | [
"0.85731363",
"0.7836477",
"0.7836477",
"0.75563234",
"0.7529806",
"0.7521614",
"0.74968386",
"0.7397085",
"0.7301993",
"0.72955334",
"0.72854245",
"0.72738886",
"0.7270647",
"0.7248709",
"0.7243295",
"0.7208719",
"0.7205121",
"0.7185704",
"0.7178388",
"0.71587324",
"0.715722... | 0.0 | -1 |
:nodoc: We need to wrap the run method so we can do things like run a cleanup method if it exists | def run(result, &progress_block) # :nodoc:
super_run(result) do |state, name|
if state == Test::Unit::TestCase::STARTED
cleanup if self.respond_to?(:cleanup)
log_start(name)
else
cleanup if self.respond_to?(:cleanup)
log_end(name)
end... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(_); end",
"def run(_); end",
"def run() end",
"def run\n raise \"Not implemented yet.\"\n end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run\n nil\n end",
"def... | [
"0.72897696",
"0.72897696",
"0.7218302",
"0.71431446",
"0.6946793",
"0.6946793",
"0.6946793",
"0.6946793",
"0.6946793",
"0.6946793",
"0.6946793",
"0.6946793",
"0.6946793",
"0.6912175",
"0.6889371",
"0.6796001",
"0.679071",
"0.6785756",
"0.67625695",
"0.67325085",
"0.67216825"... | 0.6180866 | 81 |
OAuth2 Endpoints Passport exchange Passport Strategy first exchange Insider : Client information from Apps should always be trusted | def create
@client = current_client
@session = @client.session
debug { "SessionsController#create - #{@session.inspect}"}
raise "ResourceOwner from token != session.owner" if doorkeeper_token.resource_owner_id != @session.owner.id
@client.update_attributes!(client_params)
render jso... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exchange_oauth_tokens\n end",
"def oauth_authentication; end",
"def authenticate!\n @client = Octokit::Client.new\n url = @client.authorize_url(CLIENT_ID)\n redirect url\nend",
"def use_oauth\n\t\t\t\n\t\tend",
"def on_simple_outbound\r\n {\"userCredentials\" => {\"accessToken\" => ACCESS_... | [
"0.6560234",
"0.64327234",
"0.61521095",
"0.6107974",
"0.6073148",
"0.6073148",
"0.60122347",
"0.6003596",
"0.598927",
"0.5957799",
"0.59501743",
"0.5916614",
"0.58853847",
"0.58667505",
"0.58667505",
"0.58643615",
"0.5848473",
"0.58226377",
"0.5813317",
"0.57771486",
"0.5760... | 0.0 | -1 |
JSONP endpoint based on Devise session | def id
render json: { passport_id: sso_session_id }
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show\n respond_to do |format|\n format.html {\n render\n }\n format.json { \n render :json => {:auth_key => current_user.authentication_token }, \n :callback => params[:callback] \n }\n end\n end",
"def show\n @session = Session.find(params[:id])\n sess... | [
"0.66655207",
"0.62987924",
"0.61211914",
"0.6096706",
"0.60541505",
"0.6046555",
"0.60135597",
"0.5978105",
"0.59197277",
"0.5888756",
"0.58740205",
"0.5854477",
"0.5854377",
"0.58528525",
"0.5837395",
"0.583535",
"0.58328754",
"0.58169",
"0.57637763",
"0.57604194",
"0.57442... | 0.54014283 | 68 |
Passport verification Session exists (browser/insider) return passport state Sessionless (iphone/outsider) Returns passport | def show
@session = Sso::Session.find(sso_session_id)
render json: @session, serializer: Sso::SessionSerializer
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_session\n data = { :account => Encryptor.encrypt({:id => id, :phone => phone, :password => password}.to_json, :key => $secret_key) }\n\n response = RestClient.post \"#{$service_url}/api/account/check_session\", data, { :content_type => :json, :accept => :json }\n\n JSON.parse(response)\n rescue... | [
"0.6734302",
"0.64541",
"0.6420031",
"0.6388748",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.6325727",
"0.... | 0.0 | -1 |
Retrieve a stored value from a given `key` | def [](key)
@raw[utf8(key)]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_value(key)\n self[key]\n end",
"def get(key)\n @hash.get(key)\n end",
"def get(key)\n @hash[key]\n end",
"def get(key)\n position = find(key)\n if position != nil\n @values[position]\n else\n nil\n end\n end",
"def getValue(key)\r\n \r\n ... | [
"0.828755",
"0.8140361",
"0.8138523",
"0.8110371",
"0.8025281",
"0.8020805",
"0.7993248",
"0.7978211",
"0.79378587",
"0.79378587",
"0.79378587",
"0.79378587",
"0.7860705",
"0.7829985",
"0.78287375",
"0.78061444",
"0.78035533",
"0.7777323",
"0.77565044",
"0.7743377",
"0.773992... | 0.0 | -1 |
Removes all keyvalue pairs from `self`. | def clear
@raw.clear
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cleanup!\n self.reject! { |k, v| v.empty? }\n end",
"def remove_empty_fields\n self.each_pair do |k, v|\n if self[k].class == Hash\n self[k] = self[k].remove_empty_fields\n else\n self.delete(k) if v.to_s == \"\"\n end\n end... | [
"0.72865564",
"0.6979874",
"0.682195",
"0.6734593",
"0.6729228",
"0.6694518",
"0.6661533",
"0.66526616",
"0.66008806",
"0.6592267",
"0.6575835",
"0.6532649",
"0.65251887",
"0.65058804",
"0.6482117",
"0.64808905",
"0.6468398",
"0.64671004",
"0.64671004",
"0.64598936",
"0.63897... | 0.0 | -1 |
Calls the given block once for each key in the hash, passing the keyvalue pair as parameters. If no block is given, an `Enumerator` is returned instead. | def each
return enum_for(__method__) unless block_given?
@raw.each_pair do |key, value|
yield key, value
end
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def each(&block)\n hash.each(&block)\n end",
"def each(&block)\n @hash.each {|k,v| block.call k,v }\n end",
"def each(&block)\n @hash.each(&block)\n end",
"def each(*args, &block)\n @hash.each(*args, &block)\n end",
"def each_pair(&block)\n @hash.each_pair(&block)\n ... | [
"0.8046937",
"0.8010828",
"0.7942713",
"0.756059",
"0.75390995",
"0.7518694",
"0.75044554",
"0.7473204",
"0.73918426",
"0.73157436",
"0.7315615",
"0.73091584",
"0.72909814",
"0.72860295",
"0.72446823",
"0.71660346",
"0.71633285",
"0.7125818",
"0.7098365",
"0.7098365",
"0.7092... | 0.6900659 | 24 |
Calls the given block once for each key in the hash, passing the key as a parameter. If no block is given, an `Enumerator` is returned instead. | def each_key
return enum_for(__method__) unless block_given?
@raw.each_key do |key|
yield key
end
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def each(&block)\n hash.each(&block)\n end",
"def each(&block)\n @hash.each(&block)\n end",
"def each(&block)\n @hash.each {|k,v| block.call k,v }\n end",
"def each_key(&block)\n keys.each(&block)\n end",
"def each\n @hash.each_key { |o| yield(o) }\n self\n end",
... | [
"0.7865592",
"0.775081",
"0.7693306",
"0.748823",
"0.7442418",
"0.7399876",
"0.7295237",
"0.7238419",
"0.7228679",
"0.72066975",
"0.71726716",
"0.7139497",
"0.7070028",
"0.7029381",
"0.6981385",
"0.6981385",
"0.69748366",
"0.6904482",
"0.68985206",
"0.6894795",
"0.6828259",
... | 0.7110123 | 12 |
Calls the given block once for each key in the hash, passing the value at the respective key as a parameter. If no block is given, an `Enumerator` is returned instead. | def each_value
return enum_for(__method__) unless block_given?
@raw.each_value do |value|
yield value
end
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def each(&block)\n hash.each(&block)\n end",
"def each(&block)\n @hash.each {|k,v| block.call k,v }\n end",
"def each(&block)\n @hash.each(&block)\n end",
"def each( &block ) # :yield: member, value\n\t\t\t@hash.each( &block )\n\t\tend",
"def each(*args, &block)\n @hash.each(*a... | [
"0.81592214",
"0.804703",
"0.8029286",
"0.7558101",
"0.753966",
"0.7535335",
"0.75024974",
"0.7471396",
"0.7417457",
"0.7382011",
"0.7363745",
"0.73050296",
"0.72958535",
"0.7283866",
"0.7219739",
"0.7207881",
"0.71745884",
"0.7150925",
"0.714957",
"0.714957",
"0.7143827",
... | 0.0 | -1 |
GET /users GET /users.xml | def index
@title = 'User Directory'
@users = User.where('email not ?', nil).order('first_name DESC').paginate(:page => params[:page], :per_page => User.per_page)
respond_to do |format|
format.html # index.html.erb
format.json { render :json => @users }
format.xml { render :xml => @users ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_users\n self.class.get('/users')\n end",
"def index\n @users = LinkedData::Client::Models::User.all\n respond_to do |format|\n format.html\n format.xml { render xml: @users.to_xml }\n end\n end",
"def me\n users(request(\"users/authenticate.xml\", :auth => true))\n en... | [
"0.7657926",
"0.76263535",
"0.7490723",
"0.7470033",
"0.74069935",
"0.7387062",
"0.7248585",
"0.72448206",
"0.721343",
"0.7211573",
"0.7210826",
"0.71998477",
"0.71764135",
"0.71337295",
"0.71337295",
"0.71337295",
"0.7132803",
"0.7132208",
"0.7130947",
"0.7115423",
"0.709057... | 0.0 | -1 |
GET /users/1 GET /users/1.xml | def show
@user ||= User.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @user }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @users = LinkedData::Client::Models::User.all\n respond_to do |format|\n format.html\n format.xml { render xml: @users.to_xml }\n end\n end",
"def me\n users(request(\"users/authenticate.xml\", :auth => true))\n end",
"def index\n @users = User.all\n render :xml ... | [
"0.7207235",
"0.7114702",
"0.7054687",
"0.7047563",
"0.6916399",
"0.6915569",
"0.69152325",
"0.6889017",
"0.6863717",
"0.6862916",
"0.68537647",
"0.6850865",
"0.6850865",
"0.6850865",
"0.6827962",
"0.68276834",
"0.68265396",
"0.68056685",
"0.68004096",
"0.6785998",
"0.6765893... | 0.0 | -1 |
PUT /Users/1 PUT /Users/1.xml | def update
@user = User.find(params[:id])
bSave = true
if(bSave)
bSave = @user.update_attribute(:bio,params[:user][:bio])
end
if(bSave)
bSave = @user.update_attribute(:location,params[:user][:location])
end
if(bSave)
bSave = @user.update_attribute(:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update opts = {}\n opts[:headers] ||= {}\n opts[:headers]['Content-Type'] ||= 'text/xml'\n post 'update', opts\n end",
"def put(uri, xml)\r\n req = Net::HTTP::Put.new(uri)\r\n req[\"content-type\"] = \"application/xml\"\r\n req.body = xml\r\n request(req)\r\n end",
"def upd... | [
"0.6658993",
"0.63987726",
"0.6370967",
"0.63224995",
"0.6104578",
"0.60290873",
"0.58474857",
"0.58285254",
"0.5807006",
"0.5779408",
"0.5639215",
"0.5591483",
"0.5571705",
"0.5544946",
"0.5532271",
"0.55310327",
"0.55142385",
"0.54945296",
"0.54808897",
"0.545664",
"0.54402... | 0.0 | -1 |
Get a wiki page. | def wikipage(page, subreddit = nil)
name = extract_attribute(subreddit, :display_name)
path = "/wiki/#{page}.json"
path.prepend("/r/#{name}") if subreddit
object_from_response :get, path
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_page(id)\n @client.raw('get', \"/content/pages/#{id}\")\n end",
"def get_page\n @html_doc = Nokogiri::HTML(open(\"https://en.wikipedia.org/wiki/2020_NBA_playoffs\"))\n return @html_doc\n end",
"def url\n\t\t\"#{base}/wiki/#{page}\"\n\tend",
"def wiki_page(name, path = nil, versio... | [
"0.720681",
"0.70575005",
"0.69782513",
"0.69630504",
"0.69353354",
"0.6795602",
"0.6795405",
"0.67675763",
"0.67675763",
"0.6732266",
"0.67222935",
"0.66828233",
"0.65933794",
"0.65304285",
"0.6526571",
"0.64633095",
"0.64633095",
"0.64633095",
"0.64633095",
"0.64473546",
"0... | 0.70832086 | 1 |
Yields translations to block | def each
each_locale { |locale| yield Translation.new(self, locale) }
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def translations; end",
"def __with_locale__(locale, &block)\n yield\n end",
"def each_locale_and_translated_attribute\r\n used_locales.each do |locale|\r\n translated_attribute_names.each do |name|\r\n yield locale, name\r\n end\r\n end\r\n end",
"def carry(*attri... | [
"0.65218854",
"0.6201924",
"0.61959136",
"0.61952144",
"0.6055725",
"0.5886856",
"0.58282363",
"0.58015263",
"0.57411504",
"0.573049",
"0.5680819",
"0.5674635",
"0.56733376",
"0.566249",
"0.5600197",
"0.55918765",
"0.5568261",
"0.5537879",
"0.5523076",
"0.55131483",
"0.550638... | 0.7183599 | 0 |
List locales available for this backend. | def locales
map(&:locale)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def locales\n get(\"locales\")[\"locales\"]\n end",
"def available_locales\n self.locales.map { |locale| locale.to_sym }\n end",
"def available_locales\n evaluate_localization_option!(:available_locales)\n end",
"def available_locales\n resource.translations.all(:fields => [:loca... | [
"0.775015",
"0.7720163",
"0.7659254",
"0.76236016",
"0.751332",
"0.738009",
"0.73524016",
"0.73524016",
"0.73498744",
"0.7231358",
"0.72260714",
"0.7193378",
"0.7131783",
"0.7131057",
"0.71171355",
"0.71171314",
"0.7073235",
"0.70539683",
"0.7050902",
"0.7045013",
"0.7024242"... | 0.7620866 | 4 |
Assign block to be called on model class. | def setup &block
if @setup_block
setup_block = @setup_block
exec_setup_block = method(:exec_setup_block)
@setup_block = lambda do |attributes, options, backend_class|
[setup_block, block].each do |blk|
exec_setup_block.call(self, attributes, options, backe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(&block)\n @block = block\n end",
"def initialize(&block)\n @block = block\n end",
"def initialize(&block)\n @block = block\n end",
"def parsed_model(&block)\n parsed_model_class.class_eval(&block)\n end",
"def execute(block)\n model = @wrapper... | [
"0.70473266",
"0.6913146",
"0.6913146",
"0.68325454",
"0.67524666",
"0.6699584",
"0.66709614",
"0.6657844",
"0.65972716",
"0.65951025",
"0.65910745",
"0.65881836",
"0.65776056",
"0.65776056",
"0.65776056",
"0.65776056",
"0.65776056",
"0.65776056",
"0.65776056",
"0.65776056",
... | 0.6149898 | 63 |
Build a subclass of this backend class for a given set of options | def build_subclass(model_class, options)
ConfiguredBackend.build(self, model_class, options)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(options={})\n klass = options.delete(:type)\n \n if klass\n module_eval \"#{klass.to_s.capitalize}.new(#{options})\"\n else\n assign_options(options)\n end\n end",
"def initialize_options(original_options)\n super\n\n case options[:backend]\n when Str... | [
"0.6497293",
"0.644078",
"0.6379249",
"0.63658696",
"0.6317947",
"0.62407863",
"0.61906207",
"0.6120596",
"0.60955805",
"0.607285",
"0.6040165",
"0.6028494",
"0.6020593",
"0.6006312",
"0.59902906",
"0.59701794",
"0.59594756",
"0.59489304",
"0.58794874",
"0.5850741",
"0.584996... | 0.7384247 | 0 |
Create instance and class methods to access value on options hash | def option_reader(name)
module_eval <<-EOM, __FILE__, __LINE__ + 1
def self.#{name}
options[:#{name}]
end
def #{name}
self.class.options[:#{name}]
end
EOM
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def options ; @options ||= get(:options) end",
"def get_options; end",
"def method_missing(sym, *args)\n return @options[sym]\n end",
"def options\n self[:options] || {}\n end",
"def options\n @options ||= self.class.options\n end",
"def options\n self.cl... | [
"0.7246439",
"0.7124633",
"0.7010595",
"0.70088863",
"0.6865761",
"0.6853084",
"0.68266654",
"0.68260986",
"0.6800341",
"0.67721343",
"0.6762285",
"0.6753329",
"0.674094",
"0.66978514",
"0.66870797",
"0.66870797",
"0.6676867",
"0.6676867",
"0.66763216",
"0.66605836",
"0.66605... | 0.0 | -1 |
Call setup block on a class with attributes and options. | def setup_model(model_class, attribute_names)
return unless setup_block = @setup_block
exec_setup_block(model_class, attribute_names, options, self, &setup_block)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup(&block)\n define_method(:setup, &block)\n end",
"def setup( *args )\n\t\t\tself.class.setupBlocks.each {|sblock|\n\t\t\t\tdebugMsg \"Calling setup block method #{sblock}\"\n\t\t\t\tself.send( sblock )\n\t\t\t}\n\t\t\tsuper( *args )\n\t\tend",
"def initialize(*args, &blk)\n setup(*arg... | [
"0.7373911",
"0.73719925",
"0.7358792",
"0.7341957",
"0.7304759",
"0.7248919",
"0.71910113",
"0.7184338",
"0.7184338",
"0.70105827",
"0.6975673",
"0.69716394",
"0.692515",
"0.6921935",
"0.69026744",
"0.688502",
"0.6875963",
"0.68683666",
"0.68347543",
"0.6834604",
"0.68089736... | 0.66891235 | 26 |
Show subclassed backend class name, if it has one. | def inspect
(name = superclass.name) ? "#<#{name}>" : super
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def class_name\n klass = single_class\n while klass.name == ''\n klass = klass.superclass\n end\n if list_context?\n \"[#{klass}]\"\n else\n klass.name\n end\n end",
"def backend_klass; end",
"def display_name\n class_name\n end",
"def sg_base_class_n... | [
"0.6831985",
"0.6440317",
"0.64034855",
"0.6316508",
"0.6314508",
"0.62795836",
"0.626747",
"0.626747",
"0.62649447",
"0.62633145",
"0.62614065",
"0.62553453",
"0.6237324",
"0.6225607",
"0.619343",
"0.619343",
"0.61895573",
"0.61798745",
"0.6176625",
"0.61765593",
"0.6152883"... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.