query stringlengths 7 9.5k | document stringlengths 10 1.07M | negatives listlengths 19 19 | metadata dict |
|---|---|---|---|
Build a class object using a Flat scope so we can pass through variables Then pass it as an object to setup_privileges | def objbuilder(user, type="", group="", password="")
# user becomes group when adding / deleting groups
# objbuilder("#{@thmgroupname}", "addgroup")
designobj = Class.new do
attr_reader :type, :gr... | [
"def build_top(base,*args)\n # Fills its namespace with the content of the base scope\n # (this latter may already contains access points if it has been\n # opended for extension previously).\n @namespace.concat_namespace(base.namespace)\n High.space_push(@nam... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Enables the WebAudio domain and starts sending context lifetime events. | def enable
{
method: "WebAudio.enable"
}
end | [
"def enable!\n @logger.debug(\"Enabling certificate #{@name}\")\n @enabled = true\n end",
"def enable!\n @events_tracker = EventsTracker.new(events)\n end",
"def audio_rendering_prepare(context_manager)\n end",
"def audio_player!\n @audio_player = true\n self\n end",
"def en... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Disables the WebAudio domain. | def disable
{
method: "WebAudio.disable"
}
end | [
"def unsilence\n lightstreamer_subscription.unsilence\n end",
"def disable_proxy\n broadcast('@type' => 'disableProxy')\n end",
"def disable_subscription(name)\n typed_exec(\"ALTER SUBSCRIPTION #{connection.quote_ident(name)} DISABLE\")\n end",
"def disable!\n set_enabled!(false... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Fetch the realtime data from the registered contexts. | def get_realtime_data(context_id:)
{
method: "WebAudio.getRealtimeData",
params: { contextId: context_id }.compact
}
end | [
"def fetch(context=nil)\n context.nil? ? global : named_context[context]\n end",
"def load_realtime_data\n proto = Net::HTTP.get(URI.parse(realtime_url))\n data = Transit_realtime::FeedMessage.decode(proto)\n\n schedule_data = []\n data.entity.each do |entity|\n if entity.field?(:trip... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return the supplied array as a single line CSV string | def to_csv(array)
@io.rewind
@io.truncate(0)
@csv << array
@io.rewind
@io.string
end | [
"def csv(array)\n nilfix = array.map { |s| blank(s) ? \"\" : s }\n quoted = nilfix.map { |s| '\"' + s.gsub('\"',\"'\") + '\"' }\n return quoted.join(',')\nend",
"def create_csv_row(array)\n\t\t\trow = \"\"\n\t\t\ti = 0\n\n\t\t\twhile i < array.length - 1\n\t\t\t\trow << \"'#{array[i]}', \"\n\t\t\t\ti += 1\n\t\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Crawl Method which will hit the provided service and fetch the offers. This method will filter out the merchants and offers from the set of links fetched. A merchant is created with its respective offer. | def crawl
Offer.fetch_offers
redirect_to offers_path
end | [
"def parse_offers(locator)\n page.all(:css, locator).each do |offer_sections|\n offer_sections.all(:css, 'a').each do |offer_item|\n raw_url = offer_item['href']\n link = URI.parse(raw_url)\n offer_id = offer_id_from_url(link)\n offer = OfferFactory.make_offer(offer_i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /medidas/1 GET /medidas/1.json | def show
@medida = Medida.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.json { render json: @medida }
end
end | [
"def show\n @unidade_medida = UnidadeMedida.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @unidade_medida }\n end\n end",
"def show\n @medalla = Medalla.find(params[:id])\n\n \n respond_to do |format|\n format.html # show.h... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /medidas/new GET /medidas/new.json | def new
@medida = Medida.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @medida }
end
end | [
"def new\n @medalla = Medalla.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @medalla }\n end\n end",
"def new\n @unidade_medida = UnidadeMedida.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @u... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /medidas POST /medidas.json | def create
@medida = Medida.new(params[:medida])
respond_to do |format|
if @medida.save
format.html { redirect_to @medida, notice: 'Medida se ha creado con éxito.' }
format.json { render json: @medida, status: :created, location: @medida }
else
format.html { render action: "... | [
"def create\n @unidade_medida = UnidadeMedida.new(unidade_medida_params)\n\n respond_to do |format|\n if @unidade_medida.save\n format.html { redirect_to @unidade_medida, notice: 'Unidade medida was successfully created.' }\n format.json { render :show, status: :created, location: @unidade_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /medidas/1 PUT /medidas/1.json | def update
@medida = Medida.find(params[:id])
respond_to do |format|
if @medida.update_attributes(params[:medida])
format.html { redirect_to @medida, notice: 'Medida se ha actualizado correctamente.' }
format.json { head :no_content }
else
format.html { render action: "edit"... | [
"def update\n if @medicament.update(medicament_params)\n render json: @medicament\n else\n render json: @medicament.errors, status: :unprocessable_entity\n end\n end",
"def update\n @medio = Medio.find(params[:id])\n\n respond_to do |format|\n if @medio.upd... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Retrieve keys from file/stdin | def get_keys_from_commandline(filename=nil)
ARGV << filename unless filename.nil?
return_keys = []
ARGF.each do |line|
return_keys << line.chomp!
end
ARGV << '-' # close ARGF
return_keys.each { |key| verify_key(key) }
return_keys
... | [
"def read_keys\n keys = File.open(\"nod32keysfile.txt\", \"r\").read\n fkeys = keys.each_line { |line| }\nend",
"def read_keys_file(path)\n return [] unless File.exists?(path)\n File.readlines(path).map! { |l| l.chomp.strip }\n end",
"def read_key_file_for_add(file)\n if file.nil?\n i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
called (once) when the user logs in, insert any code your application needs to hand off from guest_user to current_user. | def logging_in
current_user.absorb_from(guest_user)
end | [
"def logging_in\n # put all your processing for transferring\n # from a guest user to a registered user\n # i.e. update votes, update comments, etc.\n end",
"def logging_in\n logger.debug \"ApplicationController:logging_in >>> \"\n current_user.transfer_data(guest_user)\n end",
"def logging_in ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST request to change show to watched | def watched_tvshow
@watch = Watchlist.find_by(show_watched: false, user_id: params[:user_id], tv_show_id: params[:tv_show_id])
if @watch
@watch.update(show_watched: true)
render json: @watch
else
render json: {
error: "Something went wrong"
}
end
end | [
"def set_watched\n video = Video.find(params[:id])\n video.watched = true\n video.save\n respond_to do |format|\n format.html { redirect_to videos_url, notice: 'Video set to \"watched\".' }\n format.json { head :no_content }\n end\n end",
"def show\n @watched_model = WatchedModel.find... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /leaf_spot_imm_searches GET /leaf_spot_imm_searches.json | def index
@leaf_spot_imm_searches = LeafSpotImmSearch.all
end | [
"def index\n @leaf_spot_imms = LeafSpotImm.all\n end",
"def index\n @search = WordRoot.ransack(params[:q])\n @word_roots = @search.result.paginate(:page => params[:page], per_page: 20)\n end",
"def search\n @q = params[:q].to_s.sanitize_encoding\n\n if params[:taxon_id]\n @taxon = Taxon.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /leaf_spot_imm_searches/1 PATCH/PUT /leaf_spot_imm_searches/1.json | def update
respond_to do |format|
if @leaf_spot_imm_search.update(leaf_spot_imm_search_params)
format.html { redirect_to @leaf_spot_imm_search, notice: 'Leaf spot imm search was successfully updated.' }
format.json { render :show, status: :ok, location: @leaf_spot_imm_search }
else
... | [
"def update\n respond_to do |format|\n if @leaf_spot_imm.update(leaf_spot_imm_params)\n format.html { redirect_to @leaf_spot_imm, notice: 'Leaf spot imm was successfully updated.' }\n format.json { render :show, status: :ok, location: @leaf_spot_imm }\n else\n format.html { render ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /leaf_spot_imm_searches/1 DELETE /leaf_spot_imm_searches/1.json | def destroy
@leaf_spot_imm_search.destroy
respond_to do |format|
format.html { redirect_to leaf_spot_imm_searches_url, notice: 'Leaf spot imm search was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n @leaf_spot_imm.destroy\n respond_to do |format|\n format.html { redirect_to leaf_spot_imms_url, notice: 'Leaf spot imm was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @leaf.destroy\n respond_to do |format|\n format.html {... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /festivals/1/films/1 GET /festivals/1/films/1.xml | def show
@film = @festival.films.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @film }
end
end | [
"def show\n @fam = Fam.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @fam }\n end\n end",
"def show\n @film = Film.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /festivals/1/films/new GET /festivals/1/films/new.xml | def new
@film = @festival.films.new
respond_to do |format|
format.html { raise NonAjaxEditsNotSupported }
format.js # new.rjs
format.xml { render :xml => @film }
end
end | [
"def new\n @festival = Festival.new\n \n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @festival }\n end\n end",
"def new\n @fam = Fam.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @fam }\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /festivals/1/films POST /festivals/1/films.xml | def create
@film = @festival.films.new(params[:film])
@saved = @film.save
respond_to do |format|
format.html { raise NonAjaxEditsNotSupported }
format.js
if @saved
format.xml { render :xml => @film, :status => :created, :location => @film }
else
format.xml { re... | [
"def create\n @fam = Fam.new(params[:fam])\n\n respond_to do |format|\n if @fam.save\n flash[:notice] = 'Fam was successfully created.'\n format.html { redirect_to(@fam) }\n format.xml { render :xml => @fam, :status => :created, :location => @fam }\n else\n format.html {... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /festivals/1/films/1 PUT /festivals/1/films/1.xml | def update
@film = @festival.films.find(params[:id])
@updated = @film.update_attributes(params[:film])
respond_to do |format|
format.html { raise NonAjaxEditsNotSupported }
format.js # update.rjs
if @updated
format.xml { head :ok }
else
format.xml { render :xml... | [
"def update\n @fam = Fam.find(params[:id])\n\n respond_to do |format|\n if @fam.update_attributes(params[:fam])\n flash[:notice] = 'Fam was successfully updated.'\n format.html { redirect_to(@fam) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Look up a matching handler for the line and process it The process method on a handler always returns a Contexts object | def parse_line line, contexts
line = line.encode Encoding::UTF_8 if encode_lines?
handler = handler_for_line line
handler.process line, contexts
end | [
"def parse_line(line, contexts)\n line = line.encode Encoding::UTF_8 if encode_lines?\n\n handler = handler_for_line line\n\n handler.process line, contexts\n end",
"def process_line(line)\n if @options[:line_processor]\n @options[:line_processor].call(line)\n else... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
def create_hashes(rows) headers = ["name", "capacity", "storage"] hashes = rows.map do |row| Hash[headers.zip(row)] end hashes end Write to file | def csv_writer(rows)
headers = ["name", "capacity", "storage"]
CSV.open("reservoir_data.csv", 'w') do |csv|
csv << headers
rows.each do |row|
csv << row
end
end
end | [
"def create_hashes(headers, data_rows)\n data_rows.map { |row| headers.zip(row).to_h }\n end",
"def hashing(headers, row)\n row.map.with_index { |cell, i| [headers[i], cell] }.to_h\n end",
"def create_hash_for_files_row(row)\n Hash[* files_uniqueness_attributes.map{|attr| [attr, row[attr]]}.flatten]\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /guards/1 GET /guards/1.xml | def show
@guard = Guard.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @guard }
end
end | [
"def index\n self.class.get(\"/cards/index.xml\");\n end",
"def show\n @chance = Chance.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @chance }\n end\n end",
"def show\n @awardType = AwardType.find(params[:id])\n @awards =... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /guards/new GET /guards/new.xml | def new
@guard = Guard.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @guard }
end
end | [
"def new\n @reward = Reward.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @reward }\n end\n end",
"def new\n @regard = Regard.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @regard }\n e... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /guards/1 DELETE /guards/1.xml | def destroy
@guard = Guard.find(params[:id])
@guard.destroy
respond_to do |format|
format.html { redirect_to(guards_url) }
format.xml { head :ok }
end
end | [
"def delete(name)\r\n id = name_to_id(name)\r\n self.class.delete(\"/cards/#{id}.xml\")\r\n end",
"def delete(name)\n id = name_to_id(name)\n puts \"Deleting card with ID #{id}.\"\n self.class.delete(\"/cards/#{id}.xml\")\n end",
"def destroy\n @guarantor = Guarantor.find(params[:id])\n @... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
return all roles related with self and self account_groups | def all_roles
_role_ids_ = (account_groups.map(&:role_ids) + role_ids).flatten.uniq
Role.where(id: _role_ids_)
end | [
"def groups\n RoleMapper.roles(self)\n end",
"def all_roles\n all_my_roles = Array.new()\n roles.each do |role|\n all_my_roles << role\n end\n user_groups.each do |group|\n group.all_roles.each do |role|\n if (!all_my_roles.include?(role))\n all_my_roles << role\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Append to an option. | def append_option(key, *value)
@options[key] = ((@options[key] || []) + [value]).flatten
end | [
"def add_option(name, value); end",
"def add_option(option)\n self.class.add_option(option)\n end",
"def addOption(*args)\n commit(\"addOption\", *args)\n end",
"def append_opt(opt)\n if opt.name == :dhcp_message_type\n unless @type.nil?\n raise \"DHCP message type ALR... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adjust a list of files to include the path to the test file. | def adjust(files)
files.map { |file| @options[:path] + "/" + file }
end | [
"def add_test_files(iFilesPatternsList)\n @test_files.concat(iFilesPatternsList)\n\n return self\n end",
"def test_files=(list)\n @test_files = list\n end",
"def expanded_file_list\n test_files = Rake::FileList[pattern].compact\n test_files += @test_files.to_a if @test_files\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
is a certain type of auto configuration enabled? | def auto_config? name
return auto_config[name] if !auto_config[name].nil?
end | [
"def configured?\n true\n end",
"def auto_rules?\n @config.fetch(\"auto_rules\", false)\n end",
"def configuration?\n get_mode.to_s.include?('config')\n end",
"def autosign?\n auto = Puppet[:autosign]\n return false if ['false', false].include?(auto)\n return t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get the orm name | def orm
@orm || self.class.default_orm
end | [
"def name\n @db_name\n end",
"def orm\n @orm ||= if defined?(ActiveRecord)\n :active_record\n elsif defined?(Sequel)\n :sequel\n end\n end",
"def database_name\n persistence_context.database_name\n end",
"def default_database_name\n self.name.tableize... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Writes bytes directly to the IO object. | def write(bytes)
@io.write(bytes)
nil
end | [
"def write(bytes)\r\n end",
"def write(data)\n @io.write data\n end",
"def writebytes(str)\n flushbits\n @raw_io.write(str)\n end",
"def io(data, io)\n io.write(obj)\n end",
"def _do_write(io)\n raise \"can't write whilst reading\" if @in_read\n io.writebytes(val_to_s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Writes an 8bit boolean to the IO object. | def write_boolean(boolean)
boolean ? write_int8(1) : write_int8(0)
end | [
"def write_bool(*b); end",
"def write_bool(*b)\n b.each { |v| @content << (v ? \"\\1\" : \"\\0\") }\n self\n end",
"def write_bit(flag)\n write_bits(flag ? 1 : 0, 1)\n self\n end",
"def write_bool( *b )\n @content << b.map { |v| ( v ? 1 : 0 ).chr }.join\n end",
"def... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Writes an 8bit integer to the IO object. | def write_int8(int)
write([int].pack("C"))
end | [
"def write_uint8(value)\n write [value].pack('C')\n end",
"def u8(x)\n write [x & 0xFF]\n end",
"def write_byte(value)\n write_bytes value\n self\n end",
"def write8(data, options = {})\n dw \"w1 0x#{extract_address(data, options).to_s(16).upcase}, 0x#{extract_data(data... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Writes a 16bit integer to the IO object. | def write_int16(int)
write([int].pack("s>"))
end | [
"def write_uint16_be(value)\n write [value].pack('n')\n end",
"def write_int_16_be value\n if big_endian? then\n write to_i16(value).reverse\n else\n write to_i16(value)\n end\n end",
"def write16(data, options = {})\n dw \"w2 0x#{extrac... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Writes a 32bit integer to the IO object. | def write_int32(int)
write([int].pack("l>"))
end | [
"def write_int32(value)\n raise Int32ExceededError if value > MAX_INT32\n write_uint64(value)\n end",
"def write_uint32_le(value)\n write [value].pack('V')\n end",
"def write_uint32_be(value)\n write [value].pack('N')\n end",
"def int32(val)\n raise ArgumentErro... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Writes a 64bit integer to the IO object. | def write_int64(int)
write([int].pack("q>"))
end | [
"def write_int64(value)\n write_uint64(value)\n end",
"def write_uint64(value)\n write_varint(value)\n end",
"def write_int64( *n )\n n.each do |i|\n hi = ( i >> 32 ) & 0xFFFFFFFF\n lo = i & 0xFFFFFFFF\n @content << [ hi, lo ].pack( \"N2\" )\n e... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Writes an array to the IO object. Each item in the specified array will be yielded to the provided block; it's the responsibility of the block to write those items using the encoder. | def write_array(array, &block)
if array.nil?
# An array can be null, which is different from it being empty.
write_int32(-1)
else
write_int32(array.size)
array.each(&block)
end
end | [
"def write_array(ary)\n IOUtil.write_body(ary, out_stream)\n end",
"def write_framed_array(array) # :nodoc:\n start_pos = io.pos\n length_written = 0\n \n if process_in_bulk\n arr = []\n array.each {|item| arr.concat(item == nil ? nil_value : item) }\n length_written += io.write... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
rand generates pseudo random from 01 rand(10) generates pseudo random from 010 we use it to get something like 4.41445946155691 | def random_float
rand * rand(10)
end | [
"def randomfloat(min, max, seed=nil) # Why do I need this?\n return random(min, max, seed) / 10.0\nend",
"def random\n Kernel.rand\n end",
"def gen_speed\n rand + 15.0\n end",
"def random_number\n rand(10)\n end",
"def fltRand(min,max) \n w = max - min ;\n r = min + w * rand() ;\n return r ;... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
comprobar que el departamento se corresponde al del usuario logeado, si no es administrador. Si es adm se debera corresponder a la empresa. | def correct_dpto
if current_user.role<3 && !params[:department].nil?
unless current_user.department_id==params[:department].to_i
flash[:danger] = "ERROR: No tiene acceso al recurso solicitado"
redirect_to current_user
end
elsif current_user.role==3
redirect_to... | [
"def get_department_admin\n @agency,@dept = Agency.find(params[:agency]), Department.find(params[:dept]) \n role = @dept.role_memberships.where(:role_id=>2)\n @dept_admin = User.find(role[0].user_id) if !role.blank?\n render :layout => false\n end",
"def admin_has_dept\r\n\t\tif logged_in? && ad... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Find the legacy access controls From the Sufia.Frakenversion (Sufia6F) codebase. Create equivalent_permissions for the GenericWork or FileSet. Destroy the legacy access controls. | def migrate_permissions_for(object)
# Find any access controls for this work. The must be sufia6F style in order to not show up on the Work.
legacy_access_controls = access_controls_for object
puts "#{legacy_access_controls.count} AccessControls for #{object.class}: #{object.id}"
puts "#{object... | [
"def restore_permissions; end",
"def update_permissions\n # revoke any users that had something, but now has nothing\n revoke_user_permissions(users_to_revoke) unless users_to_revoke.empty?\n\n # set permissions for each of the permission types\n %w{full read change}.each do |p... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sift through all AccessControls and fine the ones that specify access to the given work id. | def access_controls_for(object)
all_acls.select{ |ac| ac.access_to_id == object.id }
end | [
"def clean_user_access_controls(id_list)\n inv = user_access_controls.active.pluck(:id) - id_list\n\n inv.each do |i|\n el = Admin::UserAccessControl.find(i)\n res = el.disable! admin\n Rails.logger.info \"Failed to clean up bad resource UAC: #{i}. #{el.errors.first}\" unless res\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get array of GenericWorks that are missing creator and description metadata. | def works_with_missing_metadata
GenericWork.all.select do |gw|
gw.description == [] && gw.creator == []
end
end | [
"def non_system_components\n non = []\n self.components.each do |comp|\n non << comp if comp.system_id.nil?\n end\n non\n end",
"def metadata_without_aggregate_failures(example)\n metadata = example_metadata(example) || []\n\n symbols = metadata_symbols_without_aggregate_fa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get array of FileSets that have an original file which is missing technical metadata. Minimally, check for size as a surrogate. | def file_sets_missing_metadata
FileSet.all.select do |fs|
fs.original_file && fs.original_file.file_size == []
end
end | [
"def brew_files_missing_meta\n present_file_ids = brew_file_meta.complete.pluck(:brew_file_id)\n brew_files_requiring_meta.reject{|f| f.id.in?(present_file_ids)}\n end",
"def related_files\n generic_works = self.generic_works\n return [] if generic_works.empty?\n generic_works.flat_map... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Take property value from Sufia6F predicate DC.creator write it to the current property (which uses DC11.creator as the predicate) | def update_creator_of(object)
object.creator = object.get_values(::RDF::Vocab::DC.creator)
end | [
"def create_predicate(value)\n # TODO: Semantic Properties should only be created inside, since assigning\n # one to multiple relations and then deleting breaks integrity.\n # The whole semantic property should be flattened into a field in\n # SemanticRelation anyway.\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Override this method from core vagrant, here we branch out the provision for windows FIXME: This should be removed when the core vagrant supports communication class for windows guests | def run_provisioner(env)
if env[:machine].config.vm.guest == :windows
case env[:provisioner].class.to_s
when "VagrantPlugins::Shell::Provisioner"
VagrantPlugins::VagrantHyperV::Provisioner::Shell.new(env).provision_for_windows
when "VagrantPlugins::Puppet::Pro... | [
"def WindowsGuest(box, config, name, hostname, ip, memory)\n config.vm.define name do |this|\n Guest(this, box, hostname, ip, memory)\n\n this.vm.guest = :windows\n this.vm.communicator = \"winrm\"\n this.winrm.username = \".\\\\Administrator\"\n \n SetupAnsibleProvisioning(this)\n end\nend",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
insert, autoallocating the primary key from a sequence | def insert_sequenced(row)
sql = row.type.insert_sql_minus_key
vals = row.field_values_minus_key
#$stderr.puts sql
#$stderr.puts vals.inspect
db.do(sql, *vals)
insert_id = db.select_one(row.type.get_insert_id_sql)[0]
row.send(row.type.primary_key.setter_name, insert_id)
row.reset_changed
end | [
"def set_pk_sequence!(table, value) #:nodoc:\n pk, sequence = pk_and_sequence_for(table)\n\n if pk\n if sequence\n quoted_sequence = quote_table_name(sequence)\n\n select_value(\"SELECT setval('#{quoted_sequence}', #{value})\", 'SCHEMA')\n else\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the cost for a particular resource over some duration in seconds. ALL BILLING POLICY SUBCLASSES SHOULD OVERRIDE THIS METHOD | def get_cost_for_duration(resource, duration) ; 1.0 end | [
"def get_cost_for_duration(rds_server, duration)\n hourly_cost =\n CENTS_PER_HOUR[zone_setting(rds_server)][rds_server.flavor_id]\n (hourly_cost * duration) / SECONDS_PER_HOUR\n end",
"def get_cost_for_duration(ec2_server, duration)\n return 0.0 if ec2_server... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the default billing type for this policy. Override this to set a humanreadable name for the policy. Defaults to the last part of the subclass name. | def billing_type
self.class.name.split('::').last #(defaluts to class name)
end | [
"def payment_type_display\n self.payment_type.to_s.titleize\n end",
"def default_type_label(type)\n type.name.gsub(/::/, '_').underscore\n end",
"def get_account_payment_type\n self.le_account_payment_type.nil? ? \"\" : self.le_account_payment_type.name\n end",
"def class_name\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Writes 'record' into the database if: 1. there's no previous record for this resource + billing type; or 2. the previous such record differs in hourly cost or billing codes; or 3. the records are separated by more than maximum_time_gap Otherwise, `record` is merged with the previous record that matches its resource and... | def write_or_merge_with_existing(new_record, maximum_time_gap)
write_new_record = true
last_record = BillingRecord.most_recent_like(new_record)
# If the previous record for this resource/billing type has the same
# hourly rate and billing codes, just update the previous record
if... | [
"def create_duplicate_record(record)\n #ignorable_attributes = [\"id\", \"type\", \"created_at\", \"updated_at\"]\n record_attributes = record.attributes\n self.class.ignorable_attributes.each { |ignorable_attribute| record_attributes.delete(ignorable_attribute) }\n\n duplicate_record = record.class.new... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Initializes mongo_rack. Pass in options for default override. | def initialize(app, options={})
super
host, port, db_name, cltn_name = parse_server_desc( @default_options[:server] )
@mutex = Mutex.new
@connection = ::Mongo::Connection.new(
host,
port,
:pool_size => @default_options[:pool_size],
... | [
"def init_mongodb\n Mongoid.configure do |config|\n config.database = Mongo::Connection.new(mongo_host, mongo_port).db(mongo_db_name)\n config.database.authenticate(mongo_username, mongo_password)\n# config.slaves = [\n# Mongo::Connection.new(host, 27018, :slave_ok => true).db(name)\n# ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Clean out all expired sessions | def clean_expired!
sessions.remove( { :expire => { '$lt' => Time.now } } )
end | [
"def cleanup\n logger.info(\"Cleaning up expired sessions...\", :cleanup, { state: :starting })\n begin\n count = CacheStore.cleanup(ttl: SESSION_TTL)\n logger.info(\"Deleted #{count} expired sessions.\", :cleanup, { state: :success, count: count })\n rescue StandardError => e\n logger.info(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
parse server description string into host, port, db, cltn | def parse_server_desc( desc )
tokens = desc.split( "/" )
raise "Invalid server description" unless tokens.size == 3
server_desc = tokens[0].split( ":" )
raise "Invalid host:port description" unless server_desc.size == 2
return server_desc.first, server_desc.last... | [
"def parse_servers\n tuples = config.scan(SERVER_REGEXP)\n tuples.map do |(host, vrf, authp, acctp, tout, tries, keyfm, key)|\n hsh = {}\n hsh[:hostname] = host\n hsh[:vrf] = vrf\n hsh[:auth_port] = authp.to_i\n hsh[:acct_port] ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Marshal session object BOZO !! Marshal will not dump valid strings for mongo using yaml instead | def serialize( ses )
YAML.dump( ses )
end | [
"def marshal(session)\n data = [ Marshal.dump(session) ].pack('m').chop\n \"#{data}--#{generate_digest(data)}\"\n end",
"def marshal(session)\n data = [ Marshal.dump(session) ].pack('m').chop\n \"#{data}--#{generate_digest(data)}\"\n end",
"def session_serializer; end",
"def marshal(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
merge old, new to current session state | def merge_sessions( sid, old_s, new_s, cur={} )
unless Hash === old_s and Hash === new_s
logger.error 'Bad old or new sessions provided.'
return cur
end
delete = old_s.keys - new_s.keys
logger.info "//@#{sid}: delete #{delete*','}" if not de... | [
"def restore\n if @session\n @data = @session.data\n end\n end",
"def copy_session_variables!; end",
"def session_update(fname, lname, dob)\n session[:app_fname] = fname\n session[:app_lname] = lname\n session[:app_dob] = dob\n end",
"def restore\n begin\n @hash = @ca... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks if the user wants to exit the calculator. 'Q' to exit | def exit?(ans)
ans.upcase == 'Q'
end | [
"def exit?\n user_input == \"q\" || user_input == \"quit\"\n end",
"def exit?(input)\n input == \"exit\"\n end",
"def prompt_exit\n puts 'Would you like to perform another calculation? (Y/N): '\n ans = gets.chomp.downcase\n if ans == 'y' || ans == 'yes'\n input\n calc_res\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Used to check the user input. Valid input is either "Q" or a number | def get_valid_input(input_type, options = {})
input = nil
loop do
input = gets.chomp
# binding.pry
if options.has_key?(:result) && input == ""
input = options[:result]
break
else
if input_type == "num"
numeric?(input) || input.upcase == 'Q' ? break : say("Numbers only")
... | [
"def menu_input(input)\n input.upcase == \"P\" || input.upcase == \"Q\"\n end",
"def check_input\n input = gets.strip\n puts \"-----------------------------------------------------------------------\"\n if input.to_i < 21 && input.to_i > 0 && input =~ /^\\d+$/\n display_info(in... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Displays the result of the operation performed on the two numbers | def display_result(num1, num2, operator)
# say "num1: #{num1}, num2: #{num2}, operator #{operator}"
case operator
when '1'
result = num1.to_i + num2.to_i
say "#{num1} + #{num2} = #{result}"
when '2'
result = num1.to_i - num2.to_i
say "#{num1} - #{num2} = #{result}"
when '3'
begin
res... | [
"def print_two_numbers_result(number_1, operation, number_2, result)\n\tputs \"Here is your result:\"\n\tputs number_1.to_s + operation.to_s + number_2.to_s + \" = \" + result.to_s\nend",
"def print_one_number_result(operation, number_1, result)\n\tputs \"Here is your result:\"\n\tputs number_1.to_s + operation.t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /psychologies/1 DELETE /psychologies/1.xml | def destroy
@psychology = Psychology.find(params[:id])
@psychology.destroy
respond_to do |format|
format.html { redirect_to(psychologies_url) }
format.xml { head :ok }
end
end | [
"def destroy\n @ontology = Ontology.find(params[:id])\n\tFile.delete(@ontology.location)\n @ontology.destroy\n\n\n respond_to do |format|\n format.html { redirect_to ontologies_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @psycho.destroy\n respond_to do |forma... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
string The String to be checked letter The String to be checked for. Examples index_of_char("Hello", "o") => "4" Returns the index or nil if not found. | def index_of_char(string, letter)
i = 0
while i < string.length
if string[i] == letter
return i
end
i += 1
end
return nil
end | [
"def index_of_char(str, char)\n\ti = 0\n\twhile i < str.length - 1\n\t\tif char == str[i]\n\t\t\treturn i\n\t\tend\n\t\ti += 1\n\tend\n\treturn nil\nend",
"def index_of_char(string,char)\n if char.length > 1\n return \"Char can't be longer than one character\"\n end\n if contains_char(string,char)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
check if any of its tasks is not completed | def not_completed?
tasks.any? { |task| task.done != 100 }
end | [
"def all_tasks_deferred?\n\t\tnext_tasks.size > 0 && actionable_tasks.size == 0\n\tend",
"def tasks_remain?\n\t\ttasks.any?{ |t| t.completed.nil? }\n\tend",
"def incomplete_tasks\n\t\ttasks.select{ |t| !t.completed? }\n\tend",
"def empty?; tasks.empty? end",
"def complete_tasks\n tasks.select { |t| t.don... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Select a cookbook to work on. Alert the user if the cookbook owner account has expired. | def select
@cookbook = Cookbook.find params[:id]
user_is_owner = current_user.owns_cookbook(@cookbook)
user_is_contributor = current_user.contributes_to(@cookbook)
# Verify the user is authorized to work on this cookbook.
if @cookbook && (user_is_owner || user_is_contributor)
# User mu... | [
"def cookbook_selected?\n if !current_cookbook\n redirect_to cookbooks_path, alert: \"You must have selected a Cookbook project to work on first.\"\n end\n end",
"def account_expired?\n if current_user.expired? && current_user.owns_cookbook(current_cookbook)\n redirect_to upgrade_account_path(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Edit the cookbook title. | def edit_title
@cookbook = current_cookbook
end | [
"def update_title\n @cookbook = current_cookbook\n @cookbook.title = params[:cookbook][:title]\n if @cookbook.save\n redirect_to templates_path, notice: \"Your Cookbook name has been changed!\"\n else\n render :edit_title\n end\n end",
"def alter_title\n duplicate.current_revision.c... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Update the cookbook title | def update_title
@cookbook = current_cookbook
@cookbook.title = params[:cookbook][:title]
if @cookbook.save
redirect_to templates_path, notice: "Your Cookbook name has been changed!"
else
render :edit_title
end
end | [
"def edit_title\n @cookbook = current_cookbook\n end",
"def update_title(new_title)\n \t@title = new_title\n end",
"def alter_title\n duplicate.current_revision.contents.each do |content|\n content.update_attribute(:title, \"#{content.title} (Copy)\")\n end\n end",
"def title\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Edit the cookbook introduction | def edit_introduction
@cookbook = current_cookbook
end | [
"def update_introduction\n @cookbook = current_cookbook\n\n # Process Paperclip attachments\n @cookbook.process_attachments(params)\n\n if params[:cookbook]\n @cookbook.intro_type = params[:cookbook][:intro_type] if params[:cookbook][:intro_type]\n @cookbook.center_introduction = params[:cookb... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Update introduction elements Respond with a content type of plain/text to support IE and Opera see: | def update_introduction
@cookbook = current_cookbook
# Process Paperclip attachments
@cookbook.process_attachments(params)
if params[:cookbook]
@cookbook.intro_type = params[:cookbook][:intro_type] if params[:cookbook][:intro_type]
@cookbook.center_introduction = params[:cookbook][:center_... | [
"def content_for_intro\n render_for_html(body.paragraphs[0])\n end",
"def content_for_intro(interpret=true)\n if interpret\n render_for_html(body.paragraphs[0])\n else\n body.paragraphs[0]\n end\n end",
"def update\n respond_to do |format|\n if @introtext.update(introtext_params)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Preview the cookbook This can be the current cookbook or a cookbook of another person if an order has been created (guest order) | def preview
order = current_user.orders.find_by_cookbook_id(params[:id])
@cookbook = (order) ? order.cookbook : current_cookbook
preview_path = "#{PDF_PREVIEW_FOLDER}/preview_cookbook-#{@cookbook.id}_#{Time.now.to_i}.pdf"
session[:preview_filename] = preview_path
preview = CookbookPreviewWorker.new(... | [
"def edit_introduction\n @cookbook = current_cookbook\n end",
"def edit_title\n @cookbook = current_cookbook\n end",
"def name\n raw_cookbook.cookbook_name\n end",
"def cookbook_name\n new_resource.cookbook || new_resource.cookbook_name\n end",
"def print_cookbook()\n\t\t@rec... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Preview the cookbook cover | def preview_cover
preview_path = "#{PDF_PREVIEW_FOLDER}/preview_cover-#{current_cookbook.id}_#{Time.now.to_i}.pdf"
session[:preview_filename] = preview_path
preview = CookbookPreviewWorker.new(
cookbook: current_cookbook,
filename: preview_path
)
preview.cover
render "previews/previ... | [
"def cover\n cookbook = Cookbook.find(@cookbook_id)\n @book = CookbookGenerator.new(version: :preview, cookbook: cookbook, layout: :book)\n @book.render_cover\n rendering_filename = \"#{@filename}-rendering\"\n @book.document.to_file rendering_filename\n File.rename rendering_filename, @filename\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Preview the title and the table of contents pages | def preview_title_and_toc
preview_path = "#{PDF_PREVIEW_FOLDER}/preview_title_toc-#{current_cookbook.id}_#{Time.now.to_i}.pdf"
session[:preview_filename] = preview_path
preview = CookbookPreviewWorker.new(
cookbook: current_cookbook,
filename: preview_path
)
preview.title_and_toc
re... | [
"def preview\n end",
"def link_preview_content(page)\n page.get_title.blank? ? title = page.get_url : title = page.get_title\n descr = page.get_description\n descr.blank? ? content_tag(:p, title, class: \"link-preview-title\"):\n content_tag(:p, title, class: \"link-preview-title\").concat(conten... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Preview the index page | def preview_index
preview_path = "#{PDF_PREVIEW_FOLDER}/preview_index-#{current_cookbook.id}_#{Time.now.to_i}.pdf"
session[:preview_filename] = preview_path
preview = CookbookPreviewWorker.new(
cookbook: current_cookbook,
filename: preview_path
)
preview.index
render "previews/previ... | [
"def preview_index(urls, path: request.path)\n render(path: __dir__ + \"/index.erb\", locals: { urls: Array(urls), path: path })\n end",
"def index\n @previews = Preview.all\n end",
"def preview\n end",
"def show\n render :index\n end",
"def show\n render :index\n en... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Respond with the number of pages for the current cookbook | def count_page
num_pages = current_cookbook.num_pages
render json: {num_pages: num_pages}
end | [
"def pages_count\n instance_read(:pages_count)\n end",
"def page_count\r\n @total_pages\r\n end",
"def page_count\n @page_count\n end",
"def page_count\n @total_pages\n end",
"def number_of_pages\n return @number_of_pages\n end",
"def get_page_count\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
returns a json representation of the specified element argv = commandline arguments, requires an element (e) argument, such as 'interfaces', 'hosts' or 'routes' or 'interfaces/a1' or 'hosts/dell9' | def cmd_get argv
setup argv
e = @hash['element']
response = @api.get(e)
msg JSON.pretty_generate(response)
return response
end | [
"def knife_output_as_hash(sub_cmd)\n sub_cmd = [sub_cmd, '-F json'].join(' ')\n output_lines = execute(knife_cmd(sub_cmd)).split(/\\n/)\n output_lines = output_lines.reject { |line| KNIFE_JSON_OUTPUT_IGNORE.include? line }\n json = JSON.parse output_lines.join(' ')\nrescue StandardError => e\n puts \"ERROR: #{... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
modifies a network element argv = commandline arguments, requires a json configuration (j) and the element (e) to modify, such as 'interfaces', 'hosts' or 'routes' or 'interfaces/a1' or 'hosts/dell9' | def cmd_modify argv
setup argv
json = @hash['json']
e = @hash['element']
response = @api.modify(json, e)
msg response
return response
end | [
"def create_or_update_guest_access_portal_configuration(args = {}) \n id = args['id']\n temp_path = \"/guestaccess.json/gap/{portalId}/configuration\"\n path = temp_path\nargs.keys.each do |key|\n if (key == \"portalId\")\n args.delete(key)\n path = temp_path.gsub(\"{#{key}}\", id)\n end\nend\n puts \" PAT... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
creates a new network element argv = commandline arguments, requires a json configuration (j) and the element (e) to modify, such as 'interfaces', 'hosts' or 'routes' | def cmd_create argv
setup argv
json = @hash['json']
e = @hash['element']
response = @api.create(json, e)
msg response
return response
end | [
"def cmd_modify argv\n setup argv\n json = @hash['json']\n e = @hash['element']\n response = @api.modify(json, e)\n msg response\n return response\n end",
"def create_network_equipment(network_uid, network, refapi_path, site_uid = nil)\n network_path = ''\n if site_uid\n network_path = Pat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
deletes an existing network element argv = commandline arguments, requires a json configuration (j) and the element (e) to modify, such as 'interfaces', 'hosts' or 'routes' or 'interfaces/a1' or 'hosts/dell9' | def cmd_delete argv
setup argv
e = @hash['element']
response = @api.delete(e)
msg response
return response
end | [
"def cmd_modify argv\n setup argv\n json = @hash['json']\n e = @hash['element']\n response = @api.modify(json, e)\n msg response\n return response\n end",
"def removeEndpointSet(ixNet, trafficItem, epName)\r\n puts(\"- removing \"+epName+\" endpoint set\")\r\n eps = @ixNet.getList(traffic... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
clears existing network configuration hosts argv = commandline arguments | def cmd_clear_hosts argv
setup argv
response = @api.clear_hosts
msg JSON.pretty_generate(response)
return response
end | [
"def delete_unused_host_only_networks\n end",
"def clear_hosts \n h = get(\"hosts\")\n h[\"hosts\"].each do |h|\n msg \"Clear host: #{h['name']}\", Logger::DEBUG\n delete(\"hosts/#{h['name']}\")\n end\n end",
"def clear_host!\n @host_key_files = []\n @known_host_i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
resolves network configuration hosts argv = commandline arguments, requires the name (n) of the host to resolve (determines its ip address and adds it to the network configuration) | def cmd_resolve_hosts argv
setup argv
name = @hash['name']
response = @api.resolve_hosts(name)
msg response
return response
end | [
"def parse_hosts (args)\n\n discoveryrc = File.expand_path(\"~/.discoveryrc\")\n aliasmap = {}\n if File.readable?(discoveryrc)\n File.readlines(discoveryrc).each {|line| line.scan(/(\\w+)\\s*=\\s*(.*)/) {|k,v| aliasmap[k]=v}}\n end\n\n if args.size == 0 || args[0] =~ /^-/\n @hosts = aliasm... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
clears existing network interfaces argv = commandline arguments, require the names of the interfaces to clear (i name) | def cmd_clear_interface argv
setup argv
interface = @hash['interfaces']
response = @api.clear_interface(interface)
msg response
return response
end | [
"def clear_interface(interface)\n interface = interface\n json = { \"v4_addrs\"=>[], \"v4_mask\"=>\"\", \"v4_dhcp\"=>false,\n \"v6_global_addrs\"=>[], \"v6_global_mask\"=>\"\"}\n modify json,\"interfaces/#{interface}\"\n end",
"def delete(name)\n configure([\"interface #{name}\", 'no ip addr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
clears existing network routes argv = commandline arguments | def cmd_clear_routes argv
setup argv
response = @api.clear_routes
msg response
return response
end | [
"def remove_maze_runner_args\n remove = [\n Maze::Option::SEPARATE_SESSIONS,\n Maze::Option::APP,\n Maze::Option::BS_LOCAL,\n Maze::Option::BS_DEVICE,\n Maze::Option::BS_BROWSER,\n Maze::Option::OS,\n Maze::Option::OS_VERSION,\n Maze::Option::FARM,\n Maze::Option::USE... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
saves the network configuration to a file argv = commandline arguments, requires the element (e element, such as 'interfaces', or e all) to save, and a file name (f) to save the settings to | def cmd_save argv
setup argv
e = @hash['elements']
filepath = @hash['filepath'] || "config.json"
response = @api.save(e, filepath)
msg response
return response
end | [
"def save(e=\"all\", filepath=\"config.json\") \n json = get e\n File.open(filepath,'w'){|f| f.write(JSON.pretty_generate(json))}\n end",
"def saveConfig(_filename)\n if(_filename) then\n open(File::expand_path(_filename), \"w\"){|_strm|\n _strm << JSON.pretty_generate(@conf) << \"\\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Converts the range to an equivalent exclusive range (one where exclude_end? is true) Only works for ranges with discrete steps between values (i.e. integers) | def exclusive
if exclude_end?
self
else
Range.new(self.begin, self.end + 1, true)
end
end | [
"def range beginning, ending, exclude_begin: false, exclude_end: false\n Range.new beginning, ending,\n exclude_begin: exclude_begin,\n exclude_end: exclude_end\n end",
"def split_range(range)\n start, finish = range.begin, range.end\n start += lengt... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns whether the range is empty A range is empty if end < begin or if begin == end and exclude_end? is true. | def empty?
if exclude_end?
self.end <= self.begin
else
self.end < self.begin
end
end | [
"def exclude_end?\n @ranges.size == 1 ? @ranges[0].exclude_end? : nil\n end",
"def empty?\n @interval.first == @interval.last && @interval.exclude_end?\n end",
"def exclude_begin?\n @ranges.size == 1 ? @ranges[0].exclude_begin? : nil\n end",
"def empty?\n @range_map.empty?\n en... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /steps/new GET /steps/new.json | def new
@step = Step.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @step }
end
end | [
"def new\n \n @step = Step.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @step }\n end\n end",
"def new\n\t\t@step = Step.new\n\t\trespond_to do |format|\n\t\t format.html # new.html.erb\n\t\t format.json { render :json => @step }\n\t\tend\n end"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a Zipcode Territory if one does not already exist. A zipcode territory is the first 2 digits of the zipcode for the firm. It then assigns the organization to the territory It then checks all the fields, if any are blank, it registers as an incomplete profile. | def process_before_save
zipcode = organization_zipcode.split('')[0..1].join('') if organization_zipcode.present?
teriitory = Territory.find_by_territory_identifier(zipcode)
unless teriitory
teriitory = Territory.new(territory_identifier: zipcode)
teriitory.save
end
self.territory = terii... | [
"def organization_zip_code; frozen_value_or_default(:organization_zip_code, organization.addresses.primary.blank? ? nil : organization.addresses.primary.zip_code); end",
"def create_new_postal_code\n\t\tpostal_code = PostalCode.create!(\n\t\t\tlat: @post_code_data[\"result\"][\"latitude\"].to_s,\n \tlong: @pos... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
If the organization is a customer, it gives us all Chess POs where po_lines have the customer as the organization called on. When a vendor, it shows all PO headers that were made to that vendor | def purchase_orders
case organization_type.type_value
when 'customer'
PoHeader.joins(:po_lines).where('po_lines.organization_id = ?', id).order('created_at desc')
when 'vendor'
PoHeader.where('organization_id = ?', id).order('created_at desc')
else
PoHeader.where('organization_id = ?',... | [
"def sales_orders\n case organization_type.type_value\n when 'customer'\n SoHeader.where('organization_id = ?', id).order('created_at desc')\n when 'vendor'\n SoHeader.joins(:so_lines).where('so_lines.organization_id = ?', id).order('created_at desc')\n else\n SoHeader.where('organization... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
If the organization is a customer, it gives us all Chess SO to the customer If the organization is a vendor, it shows all SO_lines where the vendor was added as the supplier. TODO: have this backfilled after the lot is chosen. Once a lot is shipped, we know the supplier. By filling this in, we can find all so_line item... | def sales_orders
case organization_type.type_value
when 'customer'
SoHeader.where('organization_id = ?', id).order('created_at desc')
when 'vendor'
SoHeader.joins(:so_lines).where('so_lines.organization_id = ?', id).order('created_at desc')
else
SoHeader.where('organization_id = ?', 0)... | [
"def purchase_orders\n case organization_type.type_value\n when 'customer'\n PoHeader.joins(:po_lines).where('po_lines.organization_id = ?', id).order('created_at desc')\n when 'vendor'\n PoHeader.where('organization_id = ?', id).order('created_at desc')\n else\n PoHeader.where('organizat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
All po line items which have a PO header to them (vendor only) used for listing vendor items | def po_items
# po_items = self.po_headers.joins(:po_lines).select("po_lines.item_id").where("po_headers.organization_id = ?",self.id).order("po_lines.created_at DESC")
po_items = PoLine.includes(:po_header).where('po_headers.organization_id = ?', id).order('po_headers.created_at DESC')
po_items = po_items.c... | [
"def orders_with_items() orders.select {|o| o.line_items_unshipped_and_uncancelled.any? } end",
"def invoiced_line_items?\n event.line_items.select{|li| !li.document_id.nil? && \n (li.payable_party == self.vendor || \n li.billable_party == self.vendor || \n (!li.inventory_item.nil? &... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
When an address is set as default, a type_category matching the comments in the method contact_type_category is created in the mastertype table. The below method creates the string using the contact_type_category method And then searches for it returning the default address (probably uses the contact id under the attri... | def default_address
type_category = contact_type_category('address')
MasterType.find_by_type_category(type_category)
end | [
"def get_default_role_contactinfo(default_contactinfo_type = 'postal')\n role_contactinfo = nil\n \n role_contactinfo = RoleContactinfo.find(:first, :conditions => ['role_id =? and contactinfo_type =?', \n self.role_id, \n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Connects to Azure and translate the toot's content | def translate_toot(toot, token)
toot_content = toot.content.strip_tags
translation_url =
"http://api.microsofttranslator.com/v2/Http.svc/Translate?" +
"text=" + toot_content + "&to=en&from=ja"
begin
response = Curl.get(translation_url) do |response|
response.headers['Authorization'] = "Bearer ... | [
"def fetch_and_translate\n ms_translator_service = Service.find_by_symbol(:microsoft)\n source.fetch_tweets.each do |tweet|\n if tweet.needs_translation?\n translation = Microsoft::Translator(tweet.text, from_lang, to_lang)\n tweet.store_translation(translation, ms_translator_service.id)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /client_events GET /client_events.json | def index
@client_events = ClientEvent.all
end | [
"def get_events()\n @client.make_request(:get, @client.concat_user_path(\"#{CALL_PATH}/#{id}/events\"))[0]\n end",
"def events\n response = self.class.get('/v1/events.json')\n response.code == 200 ? JSON.parse(response.body) : nil\n end",
"def get_events\n Resources::Event.parse(reques... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /client_events POST /client_events.json | def create
@client_event = ClientEvent.new(client_event_params)
respond_to do |format|
if @client_event.save
format.html { redirect_to @client_event, notice: 'Client event was successfully created.' }
format.json { render :show, status: :created, location: @client_event }
else
... | [
"def create\n Rails.logger.debug(\"Received event #{params[:event]}\")\n head :ok\n end",
"def create\n @event = Event.new(event_params)\n if @event.save\n render json: @event.to_json, status: :created\n else\n render json: @event.errors, status: :unprocessable_entity\n end\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /client_events/1 PATCH/PUT /client_events/1.json | def update
respond_to do |format|
if @client_event.update(client_event_params)
format.html { redirect_to @client_event, notice: 'Client event was successfully updated.' }
format.json { render :show, status: :ok, location: @client_event }
else
format.html { render :edit }
... | [
"def update\n event = event.find(params[\"id\"]) \n event.update_attributes(event_params) \n respond_with event, json: event\n end",
"def update\n respond_to do |format|\n if @event.update(event_params)\n format.json { head :no_content }\n else\n format.json { render json: @ev... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns whether to use WSSE digest. Defaults to +false+. | def digest?
!!@digest
end | [
"def digest?\n mechanism == :digest\n end",
"def digest?\n mechanism == :digest\n end",
"def digest?\n @digest || self.class.digest?\n end",
"def digest?\n !!asset_config[\"digest\"]\n end",
"def fingerprint_verification?\n !@network.options[:ssl_fingerprint].n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns a random String of 100 characters. | def random_string
(0...100).map { ("a".."z").to_a[rand(26)] }.join
end | [
"def random_str(n_bytes)\n (0..255).to_a.sample(n_bytes).map(&:chr).join\nend",
"def random_str( size=1 )\n (0...size).map{65.+(rand(25)).chr}.join\n end",
"def random_string\n [*('a'..'z'),*('0'..'9')].shuffle[0,8].join\n end",
"def random_string(length)\n random_chars(length).join\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the current target framerate (frames/second). | def target_framerate
if @target_frametime
1000.0 / @target_frametime
else
nil
end
rescue ZeroDivisionError
return nil
end | [
"def framerate\n\t\t\t\t# below is same as: return @ticks / (lifetime / 1000.0)\n\t\t\t\treturn 1000.0 * @ticks / lifetime()\n\t\t\trescue ZeroDivisionError\n\t\t\t\treturn 0\n\t\t\tend",
"def getFramesPerSecond\n @framesPerSecond\n end",
"def frame_interval\n 1.0/@fps\n end",
"def fps_float\n fram... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the target number of frames per second to +framerate+. | def target_framerate=( framerate )
if framerate
@target_frametime = 1000.0 / framerate
else
@target_frametime = nil
end
rescue ZeroDivisionError
@target_frametime = nil
end | [
"def frames_per_second=(new_fps)\n raise \"Cannot change FPS while running\" if @__running\n @fps = new_fps\n @frame_hertz = 1000.0 / @fps.to_f\n new_fps\n end",
"def frame_rate=(rate)\n @list.each { |c| c.change_frame_rate(@fps, rate) }\n @fps = rate\n end",
"def set_frame_rate(rate)\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
callseq: lifetime() > Numeric Returns time in milliseconds since this Clock instance was created. | def lifetime
Clock.runtime() - @start
end | [
"def lifetime\n Time.now.to_f - @start_time\n end",
"def lifetime_in_minutes\n return @lifetime_in_minutes\n end",
"def lifetime\n last = @points_at_times.last\n @created_at - last.time / 1000\n end",
"def cstime(*) end",
"def lifetime\n @lifetime ||= @width == ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
callseq: framerate() > Numeric Return the actual framerate (frames per second) recorded by the Clock. See tick. TODO: sample only a few seconds in the past, instead of the entire lifetime of the Clock. | def framerate
# below is same as: return @ticks / (lifetime / 1000.0)
return 1000.0 * @ticks / lifetime()
rescue ZeroDivisionError
return 0
end | [
"def framerate\n ;\n end",
"def framerate(input)\n process(:framerate, input)\n end",
"def frame_interval\n 1.0/@fps\n end",
"def frames_per_second; 1 / frame_time; end",
"def fps\n if Time.now.to_f < (@fps_init + 1.0)\n @fps_counter = @fps_counter + 1\n else\n puts @fps_coun... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get block header information. | def getblockheader(block_id, verbose)
block_hash = block_id.rhex
entry = node.chain.find_entry_by_hash(block_hash)
raise ArgumentError.new('Block not found') unless entry
if verbose
{
hash: block_id,
height: entry.height,
version: entry... | [
"def get_block_header(block_height: nil, block_hash: nil)\n params = {\n block_height: block_height,\n block_hash: block_hash\n }\n client.make_request('/get-block-header', 'post', params: params)\n end",
"def get_block_headers(options = {block_range: (0..0)}, &block)\n ge... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get current wallet information. | def getwalletinfo
node.wallet ? node.wallet.to_h : {}
end | [
"def wallet_info\n client.make_request('/wallet-info', 'post', params: {})\n end",
"def getwalletinfo\n return {} unless node.wallet\n {wallet_id: node.wallet.wallet_id, version: node.wallet.version}\n end",
"def source_wallet\n wallet\n end",
"def current_wallet\n # ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get the list of current Wallet accounts. | def listaccounts
return {} unless node.wallet
accounts = {}
node.wallet.accounts.each do |a|
accounts[a.name] = node.wallet.get_balance(a)
end
accounts
end | [
"def accounts\n []\n end",
"def accounts\n make_promise(@core.web3.JS[:personal], 'getListAccounts')\n end",
"def accounts\n transactions.map { |t| t.account }\n end",
"def accounts\n get_collection 'accounts', :class => Buxfer::Account\n end",
"def current_accounts\n\t ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.