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 |
|---|---|---|---|---|---|---|
DELETE /service_masters/1 DELETE /service_masters/1.json | def destroy
@service_master.destroy
@service_masters = ServiceMaster.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @service_type_master.destroy\n respond_to do |format|\n format.html { redirect_to service_type_masters_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @masterservice.destroy\n respond_to do |format|\n format.html { redirect_to masterservices_url,... | [
"0.7549704",
"0.74739534",
"0.7120769",
"0.69918126",
"0.6988008",
"0.6978518",
"0.69578296",
"0.69523615",
"0.69523615",
"0.69523615",
"0.6899181",
"0.68965125",
"0.68860614",
"0.68840736",
"0.68638843",
"0.6862643",
"0.6860777",
"0.6860643",
"0.6830138",
"0.6826659",
"0.680... | 0.71129304 | 3 |
Use callbacks to share common setup or constraints between actions. | def set_service_master
@service_master = ServiceMaster.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 service_master_params
params.require(:service_master).permit(:code, :name, :description, :status)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n... | [
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",... | 0.0 | -1 |
Returns the registered kind of the class of object +self+. | def kind
self.class.kind
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_class()\n l = get_type()\n #puts \"Type #{l.class} in #{self.class} , #{self}\"\n l.object_class()\n end",
"def get_class()\n l = get_type()\n #puts \"Type #{l.class} in #{self.class} , #{self}\"\n l.object_class()\n end",
"def kind\n self.class.kind\n end",
"d... | [
"0.707713",
"0.707713",
"0.7052652",
"0.7052652",
"0.7052652",
"0.69318646",
"0.6781225",
"0.6707776",
"0.6645637",
"0.66327494",
"0.65749514",
"0.65119433",
"0.6511681",
"0.6511681",
"0.6511681",
"0.64812106",
"0.64812106",
"0.6451409",
"0.6451409",
"0.64346105",
"0.63985395... | 0.71691734 | 0 |
Consumes the +sexp+ translating it into an Array suitable for input to method +args+ or +normalize+. | def consume(sexp)
out = []
sexp.each do |s|
if s.kind_of?(Array)
#
# Reject +nil+, so that we can optimize out whole expressions
# just by returning +nil+ from sexp_to_node.
#
v = @compiler.sexp_to_node(s)
out << v unless v.nil?
el... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def args(sexp)\n if call_site?(sexp)\n (rest(sexp[3])).collect { |each| Code.from_s_expression(each) }\n else\n []\n end\n end",
"def method_call_args(args_sexp)\n return [] if args_sexp[1].nil?\n args_sexp = args_sexp.last[1]\n args_sexp.map(&method(:parse_one))\n end",
"def proc... | [
"0.7726933",
"0.7499902",
"0.7418638",
"0.73796445",
"0.6804043",
"0.6681664",
"0.6582786",
"0.65823746",
"0.652859",
"0.6352124",
"0.62929857",
"0.60398704",
"0.58450884",
"0.5833182",
"0.57801664",
"0.5684614",
"0.5674687",
"0.56730276",
"0.56659514",
"0.5587061",
"0.557621... | 0.74015844 | 3 |
Used for accessing/propagating state within the AST Access dynamic state variables | def get(key)
@compiler.get(key)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __state_internal\n @state\n end",
"def define_state_accessor; end",
"def state; end",
"def state; end",
"def state; end",
"def state; end",
"def state; end",
"def state; end",
"def state; end",
"def state; end",
"def state=(_arg0); end",
"def state=(_arg0); end",
"def state=(_ar... | [
"0.63197964",
"0.6263718",
"0.62448126",
"0.62448126",
"0.62448126",
"0.62448126",
"0.62448126",
"0.62448126",
"0.62448126",
"0.62448126",
"0.6241601",
"0.6241601",
"0.6241601",
"0.62312543",
"0.62312543",
"0.62312543",
"0.61064935",
"0.6055895",
"0.604763",
"0.604763",
"0.60... | 0.0 | -1 |
Set dynamic state variables which propagate through the AST | def set(hash, &block)
@compiler.set(hash, &block)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setFSMVariable _obj, _args\n \"_obj setFSMVariable _args;\" \n end",
"def on_casgn(node)\n super\n _scope, name, = *node\n position = find_local name\n if position\n # TODO: raise error, can't re-assign contstant\n else\n ... | [
"0.62109476",
"0.6102802",
"0.5998049",
"0.5914373",
"0.5804196",
"0.5783977",
"0.57604766",
"0.56914943",
"0.56914943",
"0.56914943",
"0.56838614",
"0.5645996",
"0.5597518",
"0.5587066",
"0.5580274",
"0.55783117",
"0.55151594",
"0.5506821",
"0.54946566",
"0.54800314",
"0.544... | 0.0 | -1 |
Is +self+ of class +klass+? | def is?(klass)
self.is_a?(klass)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_a klass\n msg = \"#{self} is not a #{klass}\"\n check_if self.is_a?(klass), msg\n end",
"def instance_of?(klass)\n super || __getobj__.instance_of?(klass)\n end",
"def instance_of?(klass)\n super || object.instance_of?(klass)\n end",
"def is_a?(klass)\n __getobj__.class.obj... | [
"0.81911457",
"0.8024201",
"0.79849213",
"0.79812056",
"0.79812056",
"0.7881308",
"0.7753866",
"0.7753587",
"0.75908005",
"0.75121504",
"0.75121504",
"0.750277",
"0.73763126",
"0.73500884",
"0.71802646",
"0.70679444",
"0.703912",
"0.7024621",
"0.69830036",
"0.6940655",
"0.693... | 0.85259837 | 0 |
Eine Stehlampe wird sichtbar, wenn alle Komponenten der Stehlampe sichtbar gemacht werden | def sichtbar_machen()
@fuss.sichtbar_machen()
@stiel.sichtbar_machen()
@schirm.sichtbar_machen()
@leuchtstrahl1.sichtbar_machen()
@leuchtstrahl2.sichtbar_machen()
@leuchtstrahl3.sichtbar_machen()
@leuchtstrahl4.sichtbar_machen()
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def letzte_komponente\n \n end",
"def sichtbar_machen()\n end",
"def sichtbar_machen\n @sichtbar = true\n zeichnen()\n puts(self) \n end",
"def sichtbar_machen()\n # TODO\n end",
"def unsichtbar_machen()\n end",
"def unsichtbar_machen\n loeschen()\n @sichtbar = false ... | [
"0.7189444",
"0.66306186",
"0.6476884",
"0.64394855",
"0.6348359",
"0.6133877",
"0.5820762",
"0.57868284",
"0.57574123",
"0.568264",
"0.56513774",
"0.55251783",
"0.55251783",
"0.55251783",
"0.55251783",
"0.546585",
"0.5431152",
"0.54098946",
"0.5406905",
"0.5306613",
"0.53066... | 0.60955733 | 6 |
Eine Stehlampe wird unsichtbar wenn alle komponenten der Stehlampe unsichtbar gemacht werden | def unsichtbar_machen()
@fuss.unsichtbar_machen()
@stiel.unsichtbar_machen()
@schirm.unsichtbar_machen()
@leuchtstrahl1.unsichtbar_machen()
@leuchtstrahl2.unsichtbar_machen()
@leuchtstrahl3.unsichtbar_machen()
@leuchtstrahl4.unsichtbar_machen()
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def letzte_komponente\n \n end",
"def unsichtbar_machen()\n end",
"def sichtbar_machen()\n end",
"def zuruecksetzen()\n end",
"def unsichtbar_machen\n loeschen()\n @sichtbar = false \n end",
"def sichtbar_machen\n @sichtbar = true\n zeichnen()\n puts(self) \n end",
... | [
"0.72942615",
"0.6034785",
"0.5940375",
"0.58270395",
"0.57866514",
"0.57337886",
"0.5716815",
"0.57017624",
"0.57017624",
"0.57017624",
"0.57017624",
"0.5653898",
"0.5635757",
"0.5498021",
"0.5498021",
"0.5498021",
"0.5470622",
"0.54310805",
"0.5418579",
"0.5395117",
"0.5379... | 0.5556724 | 13 |
TODO vertikal_bewegen(anzahl_punkte) Eine Stehlampe wird vertikal bewegt, indem alle Komponenten vertikal bewegt werden. Parameter: anzahl_punkte gibt an um wieviele Punkte verschoben werden soll | def vertikal_bewegen(anzahl_punkte)
@fuss.vertikal_bewegen(anzahl_punkte)
@stiel.vertikal_bewegen(anzahl_punkte)
@schirm.vertikal_bewegen(anzahl_punkte)
@leuchtstrahl1.vertikal_bewegen(anzahl_punkte)
@leuchtstrahl2.vertikal_bewegen(anzahl_punkte)
@leuchtstrahl3.vertikal_bewegen(anzahl_punkte)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vertikal_bewegen(anzahl)\n bewegen_um_punkt(Punkt.new(0,anzahl))\n end",
"def horizontal_bewegen(anzahl)\n bewegen_um_punkt(Punkt.new(anzahl,0)) \n end",
"def langsam_vertikal_bewegen(entfernung)\n absolute_entfernung = entfernung\n if sichtbar? \n delta = 1\n if en... | [
"0.75803155",
"0.6462873",
"0.6264656",
"0.5689303",
"0.55157787",
"0.5409677",
"0.5314131",
"0.5161683",
"0.50854415",
"0.5034072",
"0.50107783",
"0.49555966",
"0.49034607",
"0.48636156",
"0.48212966",
"0.48212966",
"0.48134047",
"0.48004064",
"0.47816136",
"0.47786757",
"0.... | 0.7475189 | 1 |
TODO horizontal_bewegen(anzahl_punkte) Eine Stehlampe wird horizontal bewegt, indem alle Komponenten horizontal bewegt werden. Parameter: anzahl_punkte gibt an um wieviele Punkte verschoben werden soll | def horizontal_bewegen(anzahl_punkte)
@fuss.horizontal_bewegen(anzahl_punkte)
@stiel.horizontal_bewegen(anzahl_punkte)
@schirm.horizontal_bewegen(anzahl_punkte)
@leuchtstrahl1.horizontal_bewegen(anzahl_punkte)
@leuchtstrahl2.horizontal_bewegen(anzahl_punkte)
@leuchtstrahl3.horizontal_bewegen(anz... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def horizontal_bewegen(anzahl)\n bewegen_um_punkt(Punkt.new(anzahl,0)) \n end",
"def vertikal_bewegen(anzahl)\n bewegen_um_punkt(Punkt.new(0,anzahl))\n end",
"def vertikal_bewegen(anzahl_punkte)\n @fuss.vertikal_bewegen(anzahl_punkte)\n @stiel.vertikal_bewegen(anzahl_punkte)\n @schirm.... | [
"0.72925496",
"0.61027193",
"0.58929026",
"0.5379447",
"0.53573483",
"0.52829516",
"0.52797586",
"0.525909",
"0.52497256",
"0.52311414",
"0.5167526",
"0.51593584",
"0.5139814",
"0.51337856",
"0.5089822",
"0.50797206",
"0.50691766",
"0.5061724",
"0.50225306",
"0.500439",
"0.50... | 0.729477 | 0 |
TODO einschalten Schaltet die Stehlampe ein. Beim Einschalten werden der Lampenschirm und die Leuchtstrahlen gelb. | def einschalten()
@schirm.farbe_aendern('gelb')
@leuchtstrahl1.sichtbar_machen()
@leuchtstrahl2.sichtbar_machen()
@leuchtstrahl3.sichtbar_machen()
@leuchtstrahl4.sichtbar_machen()
@leuchtstrahl1.farbe_aendern('gelb')
@leuchtstrahl2.farbe_aendern('gelb')
@leuchtstrahl3.farbe_aendern('gel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def private; end",
"def schubert; end",
"def zuruecksetzen()\n end",
"def suivre; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def refutal()\n end",
"def probers; end",
"def verdi; end",
"def terpene; end",
"def berlioz; end",
"def malts; end",
... | [
"0.74280405",
"0.71628886",
"0.6870136",
"0.67495936",
"0.66496456",
"0.66496456",
"0.66496456",
"0.66496456",
"0.6531873",
"0.648348",
"0.63253015",
"0.63148075",
"0.62070286",
"0.619244",
"0.61620516",
"0.6161472",
"0.61490446",
"0.6121353",
"0.6060122",
"0.6051984",
"0.591... | 0.0 | -1 |
TODO ausschalten Schaltet die Stehlampe aus. Beim Ausschalten wird der Lampenschirm orange und die Leuchtstrahlen werden unsichtbar | def ausschalten()
@schirm.farbe_aendern('orange')
@leuchtstrahl1.unsichtbar_machen()
@leuchtstrahl2.unsichtbar_machen()
@leuchtstrahl3.unsichtbar_machen()
@leuchtstrahl4.unsichtbar_machen()
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def red=(_); end",
"def red; end",
"def red; end",
"def terpene; end",
"def green=(_); end",
"def red\n end",
"def suivre; end",
"def blue=(_); end",
"def legionnairs\n\n end",
"def bellini; end",
"def schubert; end",
"def refutal()\n end",
"def superweening_adorningly(counterstand_p... | [
"0.63480026",
"0.62180257",
"0.62180257",
"0.6195435",
"0.6090918",
"0.60759676",
"0.60553646",
"0.6055027",
"0.6049825",
"0.5858049",
"0.58576554",
"0.58173954",
"0.5807605",
"0.57986134",
"0.57957524",
"0.5753951",
"0.57354784",
"0.57354784",
"0.5726284",
"0.5724566",
"0.57... | 0.0 | -1 |
rows = [] rows rows puts table | def hash_to_arr(player)
hash_to_array = []
player.table.each do |x,y|
hash_to_array << "#{x}#{y}"
end
create_table(hash)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def history_report(rows)\n table = Terminal::Table.new :headings => ['Date','Exercise', 'Set', 'Weight', 'Reps'], \n :title => \"Exercise Log History\",\n :rows => rows \n puts table\nend",
"def output_table(title = '', headings, rows)\n table = Terminal::Table.new\n table.title = tit... | [
"0.7571995",
"0.7494996",
"0.7396382",
"0.7335193",
"0.72900903",
"0.72675455",
"0.7167665",
"0.7164863",
"0.7152365",
"0.71247864",
"0.7046587",
"0.7010264",
"0.70092046",
"0.7005035",
"0.69843507",
"0.6975677",
"0.6948033",
"0.69049937",
"0.68764746",
"0.6843163",
"0.682493... | 0.0 | -1 |
GET /ordems GET /ordems.json | def index
@ordems = Ordem.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @ordens = Orden.all\n render json: @ordens\n end",
"def getOrden \n \t@orden = Orden.where(:rest => params[:id_res])\n \trender json: @orden\n end",
"def index\n @ordenes = Orden.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @or... | [
"0.7425618",
"0.7182112",
"0.6949205",
"0.66160715",
"0.653922",
"0.6472049",
"0.644005",
"0.63889486",
"0.63889486",
"0.6377185",
"0.6315284",
"0.6196921",
"0.61406684",
"0.609983",
"0.6094538",
"0.60733485",
"0.6047664",
"0.6028901",
"0.6016722",
"0.601195",
"0.60028213",
... | 0.7343044 | 1 |
GET /ordems/1 GET /ordems/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getOrden \n \t@orden = Orden.where(:rest => params[:id_res])\n \trender json: @orden\n end",
"def index\n @ordens = Orden.all\n render json: @ordens\n end",
"def index\n @ordems = Ordem.all\n end",
"def index\n @ordenes = Orden.all\n\n respond_to do |format|\n format.html # index... | [
"0.75797284",
"0.7340945",
"0.7039434",
"0.6974005",
"0.6802147",
"0.6802147",
"0.6519971",
"0.6501119",
"0.6452761",
"0.64261436",
"0.6416109",
"0.637802",
"0.6321634",
"0.6308893",
"0.6267159",
"0.6247305",
"0.6224811",
"0.6175111",
"0.616847",
"0.6164189",
"0.61618423",
... | 0.0 | -1 |
POST /ordems POST /ordems.json | def create
@ordem = Ordem.new(ordem_params)
respond_to do |format|
if @ordem.save
format.html { redirect_to @ordem, notice: 'Ordem was successfully created.' }
format.json { render :show, status: :created, location: @ordem }
else
format.html { render :new }
format.js... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @orden = Orden.new(params[:orden])\n\n respond_to do |format|\n if @orden.save\n format.html { redirect_to @orden, notice: 'Orden was successfully created.' }\n format.json { render json: @orden, status: :created, location: @orden }\n else\n format.html { render ac... | [
"0.629966",
"0.59660774",
"0.5821297",
"0.58088535",
"0.58087426",
"0.57770014",
"0.57725674",
"0.57627004",
"0.5724189",
"0.57188845",
"0.56020874",
"0.56006616",
"0.5591847",
"0.55784696",
"0.55217594",
"0.55169964",
"0.55006427",
"0.5495015",
"0.54865825",
"0.5467058",
"0.... | 0.6142741 | 1 |
PATCH/PUT /ordems/1 PATCH/PUT /ordems/1.json | def update
respond_to do |format|
if @ordem.update(ordem_params)
format.html { redirect_to @ordem, notice: 'Ordem was successfully updated.' }
format.json { render :show, status: :ok, location: @ordem }
else
format.html { render :edit }
format.json { render json: @ordem.e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @ore = Ore.find(params[:id])\n \n respond_to do |format|\n if @ore.update_attributes(params[:ore])\n format.html { redirect_to @ore, notice: 'Ore was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n ... | [
"0.63438976",
"0.63092023",
"0.63092023",
"0.62058187",
"0.61583024",
"0.61366796",
"0.60985565",
"0.60947984",
"0.60888106",
"0.6077002",
"0.6071598",
"0.6065358",
"0.6064885",
"0.6052602",
"0.60346574",
"0.60184556",
"0.6008994",
"0.6008923",
"0.60022634",
"0.5998056",
"0.5... | 0.6155636 | 5 |
DELETE /ordems/1 DELETE /ordems/1.json | def destroy
@ordem.destroy
respond_to do |format|
format.html { redirect_to ordems_url, notice: 'Ordem was successfully destroyed.' }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete\n client.delete(\"/#{id}\")\n end",
"def destroy\n @orden = Orden.find(params[:id])\n @orden.destroy\n\n respond_to do |format|\n format.html { redirect_to ordenes_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @orden = Orden.find(params[:id])... | [
"0.70713896",
"0.69773066",
"0.6964826",
"0.69073784",
"0.6856611",
"0.6821957",
"0.6807641",
"0.68071806",
"0.67742455",
"0.67498964",
"0.6749857",
"0.6729382",
"0.6728905",
"0.6714401",
"0.6714287",
"0.6697991",
"0.6686482",
"0.6686176",
"0.6675933",
"0.6674856",
"0.6662325... | 0.70635885 | 1 |
Use callbacks to share common setup or constraints between actions. | def set_ordem
@ordem = Ordem.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 ordem_params
params.require(:ordem).permit(:data, :cliente, :relato, :colaborador, :resultado)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n... | [
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",... | 0.0 | -1 |
has_many :global_classifications, dependent: :delete_all has_many :global_taxons, through: :global_classifications, source: :taxon Try building a slug based on the following fields in increasing order of specificity. | def slug_candidates
[
:name_to_url,
[:name_to_url, :sku],
[:name_to_url, :sku, :site_id]
]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def subtaxa_whose_classification_needs_to_be_changed\n subtaxa = Name.subtaxa_of_genus_or_below(text_name).not_deprecated.to_a\n uniq_subtaxa = subtaxa.filter_map(&:synonym_id).uniq\n # Beware of AR where.not gotcha - will not match a null classification below\n synonyms = Name.where(deprecated: true, ... | [
"0.6048295",
"0.5771876",
"0.5755997",
"0.5754917",
"0.5754917",
"0.5715092",
"0.56437457",
"0.561554",
"0.55880743",
"0.5569522",
"0.55643654",
"0.55643654",
"0.5553974",
"0.5537942",
"0.55190116",
"0.5499645",
"0.5494031",
"0.54683447",
"0.54652363",
"0.54652363",
"0.545450... | 0.5333361 | 27 |
Returns all optional group picks for a user | def for_user(user)
group_list=user.groups.map(&:user_optional_group_pick).join(",")
conditions = ""
conditions += "id IN (#{group_list}) AND" unless group_list.empty?
conditions += "(role_id <= #{user.role_id} OR role_id IS NULL)"
UserOptionalGroupPick.all(:conditions => conditions)
en... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def for_user_with_selected(user)\n conditions = \"(id IN (#{user.groups.map(&:user_optional_group_pick).join(\",\")})) AND (role_id <= #{user.role_id} OR role_id IS NULL)\"\n picks = UserOptionalGroupPick.all(:conditions => conditions)\n picks.each do |pick|\n unless (intersection = (user.gro... | [
"0.69329786",
"0.64752686",
"0.6391191",
"0.6301416",
"0.6277793",
"0.6276514",
"0.6239401",
"0.62042683",
"0.6147166",
"0.6141781",
"0.60951453",
"0.6094769",
"0.60913664",
"0.6084481",
"0.607374",
"0.6056936",
"0.60502785",
"0.60445225",
"0.5990983",
"0.595756",
"0.5942964"... | 0.7838122 | 0 |
Returns all optional group picks for a user with the selected option for each group pick | def for_user_with_selected(user)
conditions = "(id IN (#{user.groups.map(&:user_optional_group_pick).join(",")})) AND (role_id <= #{user.role_id} OR role_id IS NULL)"
picks = UserOptionalGroupPick.all(:conditions => conditions)
picks.each do |pick|
unless (intersection = (user.groups & pick.gr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def for_user(user)\n group_list=user.groups.map(&:user_optional_group_pick).join(\",\")\n conditions = \"\"\n conditions += \"id IN (#{group_list}) AND\" unless group_list.empty?\n conditions += \"(role_id <= #{user.role_id} OR role_id IS NULL)\"\n UserOptionalGroupPick.all(:conditions => ... | [
"0.734327",
"0.6243488",
"0.6185795",
"0.6104983",
"0.60530525",
"0.60270214",
"0.5974829",
"0.5876784",
"0.58364016",
"0.5831615",
"0.5731956",
"0.5718277",
"0.56862515",
"0.56621695",
"0.5642139",
"0.56127846",
"0.5531436",
"0.5531436",
"0.5503125",
"0.5448608",
"0.54059714... | 0.72494125 | 1 |
TODO: Rename to decorated_vocabulary | def vocabulary
wayfinder.decorated_parent_vocabulary
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_instance_vocabulary_views\n return if self.vocabulary.nil?\n self.vocabulary.key_list.each {|k| add_instance_view(k)}\n instance_design_doc\n end",
"def add_instance_vocabulary_views\n return if self.vocabulary.nil?\n self.vocabulary.key_list.each {|k| add_instance_view(k)}\n instance_... | [
"0.69255877",
"0.69255877",
"0.67879504",
"0.6433755",
"0.63250095",
"0.6324542",
"0.62638915",
"0.62252206",
"0.6186369",
"0.61375266",
"0.61147577",
"0.61031765",
"0.60693675",
"0.6049297",
"0.6041185",
"0.5970617",
"0.59500045",
"0.584415",
"0.58388084",
"0.58372766",
"0.5... | 0.72697484 | 0 |
a category is just a nested vocabulary TODO: Rename to decorated_vocabularies | def categories
@categories ||= wayfinder.decorated_vocabularies.sort_by(&:label)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def categories\n add_to_query restrict_kind: 'category'\n end",
"def category\n adventure.category\n end",
"def categories\n category\n end",
"def categories\n taxonomies.all :conditions => { :classification => :category }\n end",
"def category; end",
"def category\n revision.c... | [
"0.6361074",
"0.6256138",
"0.6230612",
"0.6216884",
"0.61369336",
"0.6125785",
"0.61185235",
"0.607322",
"0.60439306",
"0.5979153",
"0.5963539",
"0.5952022",
"0.5947593",
"0.5912913",
"0.5903255",
"0.58572805",
"0.5849453",
"0.58372223",
"0.58324015",
"0.5806571",
"0.5803528"... | 0.72968405 | 0 |
TODO: Rename to decorated_ephemera_terms | def terms
@terms ||= wayfinder.decorated_ephemera_terms.sort_by(&:label)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def terms\n raise NotImplementedError\n end",
"def terms\n end",
"def terms\n\n end",
"def terms\n\n end",
"def termsig(*) end",
"def term; end",
"def terms\n\tend",
"def terms\n [self]\n end",
"def primary_terms\n terms - self.class.hyrax_form_fields\n end",
"def e... | [
"0.66673064",
"0.64938486",
"0.6469182",
"0.6469182",
"0.63910985",
"0.6194696",
"0.61887723",
"0.6053308",
"0.6029827",
"0.589088",
"0.5682934",
"0.56768566",
"0.5672608",
"0.5647448",
"0.55914557",
"0.55827516",
"0.55827516",
"0.55827516",
"0.54371905",
"0.5415531",
"0.5399... | 0.7211633 | 0 |
method that is called by parse_helper | def playGame(user, message)
#Set up the game if this is the user's first time
if user.scramble_game == nil
game = user.create_scramble_game
# game.user_id = user.id
# game.save
return initScrambleGame(game)
end
#passes on the word to the game
game = user.scramble_game
play(game, message)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse; end",
"def parse; end",
"def parse; end",
"def parse\n end",
"def parsed; end",
"def parsed; end",
"def parse()\n #This is a stub, used for indexing\n end",
"def after_parse; end",
"def after_parse; end",
"def parse\n raise \"absctract method called\"\n ... | [
"0.79691046",
"0.79691046",
"0.79691046",
"0.7809429",
"0.7802742",
"0.7802742",
"0.7758646",
"0.741533",
"0.741533",
"0.7338311",
"0.7186284",
"0.7152722",
"0.70627743",
"0.70159656",
"0.69405293",
"0.69405293",
"0.69405293",
"0.69405293",
"0.6895667",
"0.6895667",
"0.687287... | 0.0 | -1 |
Start ScrambleGame logic Main method for a game | def play(game, message)
round = game.scramble_round
score = game.score
if status(round) >= 2
return initRound(round)
end
if message[0, 6] == "-start"
return initRound(round)
end
out = checkWord(round, message)
#out << word.to_s[0,5]
if status(round) == 3
game.score = score.to_i + round.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start\r\n initialize_game\r\n until @game.over?\r\n take_turn\r\n end\r\n print_outcome\r\n end",
"def start_game\n game_logo\n game_start_screen\n game_rules\n last_rules\n choice = maker_breaker\n game_maker if choice == 'm'\n game_breaker if choice == 'b'... | [
"0.7349935",
"0.73076195",
"0.73068",
"0.71988887",
"0.71523744",
"0.7148998",
"0.7100178",
"0.70946956",
"0.708954",
"0.7081722",
"0.7074511",
"0.7072987",
"0.7059057",
"0.7026563",
"0.7014751",
"0.6986009",
"0.69219047",
"0.6912558",
"0.68880934",
"0.68642324",
"0.68361664"... | 0.0 | -1 |
end play Sets up a game, run only if a user doesn't have a game | def initScrambleGame(game)
initWords()
game.update_attributes score: 0
game.create_scramble_round
round = game.scramble_round
initRound(round)
initRound(round)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_game(user)\n $game_session = nil\n UserGuess.delete_all\n\n initiate_game(user)\n question_loop\n end_message\n menu(user)\nend",
"def play\n # unless the game is over players take turns\n take_turn until game_over?\n\n #start a new game if the game is over\n new_game_or_quit\n end",... | [
"0.7269086",
"0.7238647",
"0.7231406",
"0.714167",
"0.7071981",
"0.7053089",
"0.7025451",
"0.70133954",
"0.69383496",
"0.692823",
"0.6912096",
"0.6900278",
"0.68598217",
"0.6848562",
"0.6837065",
"0.6819435",
"0.6811782",
"0.6765006",
"0.67506707",
"0.6748519",
"0.6743812",
... | 0.0 | -1 |
Start ScrambleRound logic Sets up a round. Called each time a new round is made | def initRound(round)
i = Random.rand(1..50)
round.roundScore = 10
round.usedHint = 0
round.correctWord = @wordList[i]
#round.correctWord = get_random(4, 8)
#round.correctWord = "apple"
round.correctWord = round.correctWord.to_s
round.scrambledWord = randomizeString(round.correctWord).to_s
round.save
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_round!\n @players.each { |player| player.empty_hand! }\n @players_in_round.replace(@players)\n @round_winner = nil\n ante_up!\n deal_initial_hands\n end",
"def beginBetting\r\n\tprintLine\r\n\tstartBetRound\r\n\tprintLine\r\n\tstartBetting\r\n\t@new_round = false... | [
"0.74133325",
"0.6861252",
"0.6759349",
"0.6725576",
"0.66460836",
"0.65486395",
"0.6508009",
"0.6486761",
"0.64758724",
"0.64591175",
"0.6457222",
"0.6361314",
"0.6350842",
"0.62894386",
"0.6280015",
"0.6276726",
"0.6261579",
"0.62566584",
"0.6247394",
"0.6244581",
"0.624346... | 0.7116682 | 1 |
Checks if a word is correct. Handles parsing for "hint" | def checkWord(round, inWord)
#Logic to deal with word
if inWord[0, 5] == "-hint"
if round.usedHint == 0
if round.roundScore <=4
return "You have used too many guesses to use your hint!"
end
round.roundScore += -4
round.usedHint = 1
return hint(round.correctWord)
else
return "Y... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_word(word)\n if self.player.word_list.include?(word)\n puts \"Already found that one!\"\n elsif word.length < 4\n puts \"That word is too short. Words must be 4 letters or longer.\"\n elsif word.chars.include?(self.board.inner_letter) == false\n puts \"Missing center letter.\"\n ... | [
"0.732869",
"0.70052326",
"0.69552815",
"0.67844737",
"0.6784141",
"0.6771078",
"0.67493206",
"0.673752",
"0.6708885",
"0.66962487",
"0.6688009",
"0.66397715",
"0.6616572",
"0.6613002",
"0.659509",
"0.65747213",
"0.6557829",
"0.65430355",
"0.65360665",
"0.6446802",
"0.6442005... | 0.7209456 | 1 |
end checkWord Returns the definition of a word. Can only be used once per round | def hint(word)
get_definition(word)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_for_definitions\n @words.each do |word|\n @lemma ? lemma = \" - #{@lemmas[word]}\" : lemma = \"\"\n\n # Strip characters - mimics trimWordLowerCase in texts.js\n regex = /[\\u200B-\\u200D\\uFEFF\\u00A0]/\n word.gsub!(regex, \"\")\n regex = /^[.,!¡?¿:;\\/|\\\\'\"“”‘... | [
"0.72379375",
"0.71943927",
"0.7089018",
"0.7043437",
"0.7043437",
"0.7043437",
"0.7043437",
"0.7043437",
"0.6996515",
"0.68594396",
"0.6797021",
"0.67428935",
"0.67413425",
"0.66960603",
"0.6687422",
"0.6663738",
"0.665114",
"0.6646196",
"0.66287804",
"0.6596279",
"0.6592638... | 0.6724004 | 13 |
Returns the status of the given round. | def status(round)
round.usedHint
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def status\n case completed_rounds.size\n when 0 then :hasnt_started\n when ROUNDS.size then :completed\n else :in_progress\n end\n end",
"def get_status()\n\n puts \"Rounds: #{@rounds}\"\n puts \"Player wins: #{@player_wins}\"\n puts \"... | [
"0.7130492",
"0.656539",
"0.65178776",
"0.642484",
"0.6402165",
"0.63747376",
"0.63335466",
"0.6230013",
"0.62278306",
"0.62218946",
"0.6193923",
"0.61853224",
"0.6149045",
"0.6149045",
"0.61204344",
"0.60412484",
"0.59927905",
"0.59721726",
"0.59556365",
"0.592826",
"0.58584... | 0.7725389 | 0 |
Never trust parameters from the scary internet, only allow the white list through. | def double_mattress_one_params
params.require(:double_mattress_one).permit(:name, :gender, :age, :email, :weight,
:length, :sleep_position, :body_shape, :warm_sleeping,
:neck_or_back_pain, :session_id, :mattress_length,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n... | [
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",... | 0.0 | -1 |
curl d "client_id=160603714647&client_secret=zJsqR9XiRaJQzDjpxxpqgS3FAq0Equkp&grant_type=authorization_code& code=f83fb7f4db89231a939f8ca56f5670ae&redirect_uri= | def data_acc_token(code, client_id, client_secret, grant_type="authorization_code", redirect_uri=REDIRECT_URL)
"client_id=#{client_id}&client_secret=#{client_secret}&grant_type=#{grant_type}&code=#{code}&redirect_uri=#{redirect_uri}"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def request(code:, redirect_uri: Keap::REST.redirect_uri)\n body = {\n client_id: Keap::REST.client_id,\n client_secret: Keap::REST.client_secret,\n code: code,\n grant_type: \"authorization_code\",\n redirect_uri: redirect_uri\n }\n\n ... | [
"0.6782264",
"0.67442983",
"0.67113537",
"0.66831654",
"0.66799355",
"0.66406083",
"0.6621363",
"0.6568282",
"0.6564558",
"0.65446275",
"0.6481472",
"0.64684767",
"0.6441047",
"0.6428085",
"0.6411563",
"0.6404167",
"0.6311375",
"0.63090146",
"0.63060147",
"0.62915593",
"0.627... | 0.7078704 | 0 |
GET /sites/1 GET /sites/1.json | def show
update_and_decorate
smartrender
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @sites = Site.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @sites }\n end\n end",
"def index\n @sites = Site.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @sites }\n end\n... | [
"0.7444836",
"0.7444836",
"0.7214904",
"0.7204854",
"0.7108241",
"0.70891887",
"0.70891887",
"0.70891887",
"0.7068557",
"0.703299",
"0.69449097",
"0.68207115",
"0.68081486",
"0.67804134",
"0.67772996",
"0.6742932",
"0.67404276",
"0.6618609",
"0.656212",
"0.6556428",
"0.655562... | 0.0 | -1 |
GET /sites/new GET /sites/new.json | def new
# return if need_login true, true
update_and_decorate
response_service.title = "New Site"
render :edit
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n @site = Site.new\n \n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @site }\n end\n end",
"def new\n @site = Site.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @site }\n end\n end",
... | [
"0.80053765",
"0.79289687",
"0.79289687",
"0.79289687",
"0.79289687",
"0.76236874",
"0.7538435",
"0.7462429",
"0.72648567",
"0.72642076",
"0.725427",
"0.71223825",
"0.7115141",
"0.70964307",
"0.7091733",
"0.7066875",
"0.70665777",
"0.7032004",
"0.70274115",
"0.70027065",
"0.6... | 0.0 | -1 |
POST /sites POST /sites.json | def create
update_and_decorate
respond_to do |format|
if !@site.errors.any?
format.html { redirect_to @site, notice: 'Site was successfully created.' }
format.json { render json: @site, status: :created, location: @site }
else
format.html { render action: "new" }
for... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @site = current_user.sites.create(params[:site])\n respond_to do |format|\n if @site.save\n format.html { flash_and_redirect(\"successfully saved!\", sites_url) }\n format.json { render json: @site, status: :created, location: @site }\n else\n format.html { render ... | [
"0.67946297",
"0.66968215",
"0.65516245",
"0.65030956",
"0.64209604",
"0.64209604",
"0.64209604",
"0.6335178",
"0.63177776",
"0.629245",
"0.62879896",
"0.6279627",
"0.6162099",
"0.61234045",
"0.6087425",
"0.6069964",
"0.6069242",
"0.6069242",
"0.6049953",
"0.60482645",
"0.602... | 0.5690528 | 52 |
PUT /sites/1 PUT /sites/1.json | def update
if update_and_decorate
respond_to do |format|
format.html { redirect_to @site, notice: 'Site #{@site.name} was successfully updated.' }
format.json {
flash[:popup] = "#{@site.name} updated"
render :update
}
end
else
if @site
post_r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @site = current_user.sites.find(params[:id])\n\n respond_to do |format|\n if @site.update_attributes(params[:site])\n format.html { flash_and_redirect(\"successfully updated!\", sites_url) }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" ... | [
"0.6714442",
"0.6679554",
"0.66156656",
"0.6500878",
"0.64867646",
"0.64633393",
"0.6455145",
"0.6401375",
"0.63247436",
"0.6320626",
"0.63044417",
"0.6296157",
"0.62479657",
"0.6227342",
"0.6216542",
"0.6211085",
"0.619438",
"0.61918175",
"0.61918175",
"0.61883056",
"0.61883... | 0.56141543 | 75 |
DELETE /sites/1 DELETE /sites/1.json | def destroy
# return if need_login true, true
@site = Site.find params[:id]
@site.destroy
respond_to do |format|
format.html { redirect_to sites_url }
format.json { head :ok }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @site.destroy\n\n respond_to do |format|\n format.html { redirect_to sites_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @site.destroy\n respond_to do |format|\n format.html { redirect_to sites_url }\n format.json { head :no_content }\n ... | [
"0.7356214",
"0.73258954",
"0.73258954",
"0.73258954",
"0.73258954",
"0.73258954",
"0.7317765",
"0.7289903",
"0.7289903",
"0.7289903",
"0.7289903",
"0.7289903",
"0.7289426",
"0.7267864",
"0.72534925",
"0.7246142",
"0.7225299",
"0.7222419",
"0.7191969",
"0.71299064",
"0.710079... | 0.6695226 | 65 |
One pass using a stack | def remove_nth_from_end3(head, n)
node=head
stack=[]
until node.nil?
stack.push(node)
node=node.next
end
return head.next if stack.length == n #Remove first node
(n+1).times {node = stack.pop} #Middle and last nodes
node.next=node.next.next
return head
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stack(*args); end",
"def stack; end",
"def stack; end",
"def StartStack\n\n end",
"def take_from_stack\n stack.pop\n end",
"def to_stack; end",
"def push\n CGContextSaveGState(@ctx)\n @stacksize = @stacksize + 1\n end",
"def push_stack\n bb = {:black => get_black,:white => ... | [
"0.7622253",
"0.7207581",
"0.7207581",
"0.66762197",
"0.6608391",
"0.6566702",
"0.65523124",
"0.64558053",
"0.6427265",
"0.6393154",
"0.6296804",
"0.6185683",
"0.61577433",
"0.6111072",
"0.60920596",
"0.6079776",
"0.6078906",
"0.6051927",
"0.60299385",
"0.6003411",
"0.599751"... | 0.0 | -1 |
One pass. No additional space. Two pointers | def remove_nth_from_end(head, n)
node1 = node2 = head # Two pointers
n.times do
return head.next if node2.next.nil?
node2=node2.next
end
node1=node1.next until (node2=node2.next).nil?
node1.next=node1.next.next #Remove node n
return head
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def *(p0) end",
"def *(p0) end",
"def *(p0) end",
"def store(p0, p1) end",
"def two1 a; a[0] + a[1] end",
"def []=(p0, p1) end",
"def []=(p0, p1) end",
"def &(p0) end",
"def &(p0) end",
"def swap_fix_it(p1, p2)\n\n p1_copy = p1.dup\n \n p1.x = p2.x\n p1.y = p2.y\n\n p2.x = p1_copy.x\n p2.y ... | [
"0.6253374",
"0.6253374",
"0.6252994",
"0.6175468",
"0.6047269",
"0.6002611",
"0.6002611",
"0.59984654",
"0.59984654",
"0.5845303",
"0.58429253",
"0.5815255",
"0.5815255",
"0.57969266",
"0.5779903",
"0.5778763",
"0.55499846",
"0.54909176",
"0.5467767",
"0.5439011",
"0.5435452... | 0.0 | -1 |
Returns a new instance of Vedeu::Renderers::EscapeSequence. | def initialize(output)
@output = output
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize\n super(name: 'Escape')\n end",
"def _escape(object)\n ::Hanami::View::Escape::Presenter.new(object)\n end",
"def escape(target)\n new(target.to_s.gsub(/[#{Entities}]/) {|m| \"&#{Encode[m]};\" })\n end",
"def initialize(output, escape_from = nil)\n @out... | [
"0.61984944",
"0.55808824",
"0.5510202",
"0.54157424",
"0.53599584",
"0.53272575",
"0.52848655",
"0.5152683",
"0.50377053",
"0.502366",
"0.4988816",
"0.4969157",
"0.49680075",
"0.49486387",
"0.49412054",
"0.49386084",
"0.48958707",
"0.4875744",
"0.48671928",
"0.48668352",
"0.... | 0.0 | -1 |
Escapes the escape sequences. | def parsed
@parsed ||= Array(output).flatten.map do |char|
Esc.escape(char.to_s) + "\n"
end.join
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def escape(*chars)\n gsub(/(?<!\\\\)(#{chars.join(\"|\")})/) do |char|\n \"\\\\\" + char\n end\n end",
"def escape(string); end",
"def escape(text)\n return text.gsub(/[\\`*_{}\\[\\]()#+\\-.!]/, \"\\\\\\\\\\\\0\")\n end",
"def escape(stream = '')\n return stream if abse... | [
"0.7433243",
"0.7394004",
"0.7252334",
"0.7153068",
"0.7028619",
"0.6949779",
"0.6939599",
"0.6803806",
"0.6745386",
"0.67050564",
"0.66434574",
"0.6615006",
"0.65891075",
"0.6580175",
"0.6580175",
"0.6580175",
"0.6580175",
"0.6580175",
"0.6580175",
"0.6580175",
"0.6580175",
... | 0.0 | -1 |
GET /magisterial_districts GET /magisterial_districts.json | def index
@magisterial_districts = MagisterialDistrict.where(user_id: current_user.user_id).search(params[:search]).paginate(page: params[:page], per_page: 50).order('updated_at DESC')
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_magisterial_district\n @magisterial_district = MagisterialDistrict.find(params[:id])\n end",
"def show\n @districtclass = Districtclass.find(params[:id])\n @districts = @districtclass.districts.all(:order => 'district_name')\n\n respond_to do |format|\n format.html # show.html.erb\n... | [
"0.7035503",
"0.6979753",
"0.68250364",
"0.6799545",
"0.66891664",
"0.66223246",
"0.6576849",
"0.6494897",
"0.6446574",
"0.64063174",
"0.63703495",
"0.63409287",
"0.6323352",
"0.62738657",
"0.6258018",
"0.6199975",
"0.617803",
"0.61627305",
"0.6137722",
"0.6124771",
"0.609435... | 0.68578106 | 2 |
GET /magisterial_districts/1 GET /magisterial_districts/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_magisterial_district\n @magisterial_district = MagisterialDistrict.find(params[:id])\n end",
"def show\n @districtclass = Districtclass.find(params[:id])\n @districts = @districtclass.districts.all(:order => 'district_name')\n\n respond_to do |format|\n format.html # show.html.erb\n... | [
"0.7301953",
"0.7014119",
"0.6937816",
"0.682459",
"0.6764693",
"0.6749708",
"0.67492706",
"0.6677338",
"0.66005427",
"0.6466002",
"0.6451877",
"0.6450642",
"0.6437659",
"0.6380719",
"0.636016",
"0.6306895",
"0.6305034",
"0.62844163",
"0.62758005",
"0.6273465",
"0.6269933",
... | 0.0 | -1 |
POST /magisterial_districts POST /magisterial_districts.json | def create
#@magisterial_district = MagisterialDistrict.new(magisterial_district_params)
@zone = Zone.find_by(zone_description: params[:magisterial_district][:magisterialdistrict_zone])
if !@zone
@zone1 = Zone.create!(zone_description: params[:magisterial_district][:magisterialdistrict_zone],user_id... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @district = District.new(district_params)\n\n respond_to do |format|\n if @district.save\n format.html { redirect_to @district, notice: 'District was successfully created.' }\n format.json { render :show, status: :created, location: @district }\n else\n format.html... | [
"0.7025748",
"0.7025748",
"0.68858445",
"0.6882479",
"0.68403846",
"0.6701153",
"0.6660749",
"0.6638711",
"0.6626325",
"0.66118777",
"0.66081536",
"0.66016495",
"0.65715176",
"0.65500635",
"0.64203984",
"0.64111423",
"0.63387215",
"0.63387215",
"0.6277854",
"0.62676394",
"0.6... | 0.63583875 | 16 |
PATCH/PUT /magisterial_districts/1 PATCH/PUT /magisterial_districts/1.json | def update
respond_to do |format|
if @magisterial_district.update(magisterial_district_params)
@dis1 = @magisterial_district.created_at.to_s + "$" + @magisterial_district.magisterialdistrict_zone.to_s + '$' + @magisterial_district.magisterialdistrict_district.to_s + '$' + @magisterial_district.magiste... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @district = District.find(params[:id])\n\n respond_to do |format|\n if @district.update_attributes(params[:district])\n flash[:success] = \"Район успешно отредактирован.\"\n format.html { redirect_to @district }\n format.json { head :no_content }\n else\n fl... | [
"0.67293596",
"0.6675795",
"0.6675795",
"0.66723055",
"0.65453947",
"0.650972",
"0.6494883",
"0.64921963",
"0.6402152",
"0.6390123",
"0.6344601",
"0.62592256",
"0.62512594",
"0.62512594",
"0.6128648",
"0.6090195",
"0.6084774",
"0.6055886",
"0.6035119",
"0.60142046",
"0.600701... | 0.617227 | 14 |
DELETE /magisterial_districts/1 DELETE /magisterial_districts/1.json | def destroy
@magisterial_district.destroy
respond_to do |format|
format.html { redirect_to magisterial_districts_url, notice: 'Magisterial district was successfully destroyed.' }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @district.destroy\n respond_to do |format|\n format.html { redirect_to admin_districts_url, notice: '删除成功!' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @clidistrict = Clidistrict.find(params[:id])\n @clidistrict.destroy\n\n respond_to do |format|\n... | [
"0.74152",
"0.73835677",
"0.7350727",
"0.7344662",
"0.73413295",
"0.73082995",
"0.73082995",
"0.7275211",
"0.7244149",
"0.7228908",
"0.7148574",
"0.71406156",
"0.7019948",
"0.6927039",
"0.6927039",
"0.68556404",
"0.6844657",
"0.6836599",
"0.6759194",
"0.6756045",
"0.67435825"... | 0.7899928 | 0 |
Use callbacks to share common setup or constraints between actions. | def set_magisterial_district
@magisterial_district = MagisterialDistrict.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 magisterial_district_params
params.require(:magisterial_district).permit(:user_id, :magisterialdistrict_zone, :magisterialdistrict_district, :magisterialdistrict_code, :magisterialdistrict_province)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n... | [
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",... | 0.0 | -1 |
=== self ==== Authorizations ==== | def allow_to? action, editor
case action
when :create
true
when :read
false
when :update
false
when :delete
editor.data._id == owner!.fetch('_id')
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def authorizations\n @@authorized_actions ||= {}\n @@authorized_actions\n end",
"def authorization; end",
"def index\n @authorizations = Authorization.all\n end",
"def index\n @authorizations = Authorization.all\n end",
"def ach_authorizations(entity_id)\n API::request(:get, \"e... | [
"0.7339607",
"0.7142362",
"0.7054916",
"0.7054916",
"0.6971667",
"0.6871236",
"0.6871236",
"0.68635637",
"0.68391144",
"0.6629766",
"0.65932447",
"0.65372276",
"0.6515634",
"0.6515634",
"0.6507924",
"0.6427242",
"0.6396003",
"0.63493145",
"0.62674475",
"0.62462544",
"0.624302... | 0.0 | -1 |
Returns a string which describes this task. | def description
"This task hits the Corpwatch API and creates an object for all found entities."
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_s # Method to display completion status and description of Task\n \"#{represent_status} : #{description}\"\n end",
"def task_details_for_log\n \"Node #{@puppet_mclient.node_id}, task #{@task}, manifest \"\\\n \"#{@puppet_mclient.manifest}\"\n end",
"def taskDescription _args\n \"ta... | [
"0.799827",
"0.7680068",
"0.7404178",
"0.7316715",
"0.7292764",
"0.72387326",
"0.71553576",
"0.714361",
"0.7133372",
"0.7100784",
"0.70201147",
"0.70195675",
"0.7015218",
"0.7006205",
"0.6996942",
"0.6971912",
"0.69639343",
"0.694675",
"0.69346523",
"0.6879938",
"0.6846278",
... | 0.60670894 | 93 |
Returns an array of valid types for this task | def allowed_types
[SearchString]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tasks_for(object)\n tasks_for_type = []\n\n @tasks.each do |task|\n if task.allowed_types.include?(object.class)\n tasks_for_type << task\n end\n end\n\n tasks_for_type\n end",
"def get_task_types_eng\n [\"vat_jan\", \"vat_mar\", \"vat_may\", \"vat_jul\", \"vat_sept\", \"... | [
"0.6776899",
"0.67113894",
"0.6647227",
"0.6628171",
"0.64743054",
"0.6272285",
"0.62337744",
"0.62003124",
"0.61788154",
"0.6147509",
"0.61128145",
"0.6110746",
"0.6025798",
"0.59960765",
"0.59960765",
"0.5962587",
"0.5962587",
"0.5962587",
"0.5962587",
"0.5962587",
"0.59515... | 0.0 | -1 |
Default method, subclasses must override this | def run
super
# Attach to the corpwatch service & search
x = Ear::Client::Corpwatch::CorpwatchService.new
corps = x.search @object.name
corps.each do |corp|
# Create a new organization object & attach a record
o = create_object Organization, {
:name => corp.name,
}
o.physical_locatio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def overrides; end",
"def custom; end",
"def custom; end",
"def default; end",
"def default; end",
"def private; end",
"def special\n override\n end",
"def defaults\n super\n end",
"def implementation; end",
"def implementation; end",
"def default\n end",
"def defaults; end",
... | [
"0.7415348",
"0.73554313",
"0.73554313",
"0.6991004",
"0.6991004",
"0.69613177",
"0.69572926",
"0.6824949",
"0.6801543",
"0.6801543",
"0.67361915",
"0.66934764",
"0.66934764",
"0.66934764",
"0.66934764",
"0.66934764",
"0.66934764",
"0.66934764",
"0.66934764",
"0.66934764",
"0... | 0.0 | -1 |
given right and down, we continually move in those increments and count trees hit. if we hit the right edge of the map, continue back wrapping on the left side (cylinder). End when we hit the bottom. returns: count of trees hit | def trees_on_slope(right:, down:)
x = 0
y = 0
count = 0
loop do
count += 1 if map(x, y) == "#"
x += right
y += down
break if y >= @height
end
count
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def traverse(map, right, down)\n bottom = map.count\n x, y, level, trees = 0, 0, 1, 0\n\n while level < bottom do\n x += right\n y += down\n trees += 1 if map[y][x.remainder(map[0].size)] == \"#\"\n level += down\n end\n trees\nend",
"def tree_checker(map,right,down)\n horz = 0\n counter = 0\n... | [
"0.71847934",
"0.6974354",
"0.6372562",
"0.62935925",
"0.6131845",
"0.61261404",
"0.6034334",
"0.60340583",
"0.594764",
"0.5928487",
"0.5909727",
"0.5852644",
"0.58415204",
"0.57238865",
"0.5680727",
"0.5680035",
"0.56683224",
"0.5639057",
"0.56215173",
"0.56213963",
"0.56117... | 0.7114001 | 1 |
top left is 0,0, moving right and down is positive. | def map(x, y)
return nil if y >= @height
@text_lines[y][x % @width]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_left\n\t\tmove([-1,0])\n\tend",
"def move_down\n\t\tmove([0,1])\n\tend",
"def move_up\n current_y = position[0] - 1\n position[0] = (current_y < 0 ) ? (width-1) : current_y\n end",
"def move_up_left\n i = 1\n until false\n x, y = @pos\n x -= i\n y -= i\n pos = [x, y]... | [
"0.73159647",
"0.7291958",
"0.713752",
"0.70265347",
"0.694619",
"0.6867119",
"0.6863916",
"0.6831575",
"0.6798406",
"0.6652431",
"0.6638478",
"0.66245294",
"0.6616558",
"0.6605461",
"0.6594733",
"0.6540594",
"0.6539586",
"0.6514284",
"0.64754575",
"0.64122313",
"0.6363974",
... | 0.0 | -1 |
Since Data Objects are not "Marshallable", and they generally contain lots of types of data in their instance variables, we have this method. This will create and return a 'deep copy' of the data object as well as any and all nested data objects and collections it contains. Please note that this method will fail if you... | def data_object_copy
opts = {}
self.instance_variables.each do |var|
key = var.to_s.gsub('@','').to_sym
orig_val = instance_variable_get var
opts[key] = case
when orig_val.kind_of?(CollectionsFactory)
orig_val.copy
when orig_val.ins... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deep_copy\n Marshal.load(Marshal.dump(self))\n end",
"def deep_copy\n Marshal.load(Marshal.dump(self))\n end",
"def deep_copy\n Marshal.load(Marshal.dump(self))\n end",
"def deep_copy\n Marshal.load(Marshal.dump(self))\n end",
"def deep_copy\r\n Marshal.load(Marshal... | [
"0.7011679",
"0.69687396",
"0.6947443",
"0.6947443",
"0.69451165",
"0.6902215",
"0.6899989",
"0.6882338",
"0.6851656",
"0.6847303",
"0.67907864",
"0.67907864",
"0.6748858",
"0.6739522",
"0.6715923",
"0.6710733",
"0.6681505",
"0.6598908",
"0.65953803",
"0.6591149",
"0.65718746... | 0.775375 | 0 |
Add this to the bottom of your Data Object's initialize method. This method does 2 things: 1) Converts the contents of the hash into the class's instance variables. 2) Grabs the names of your collection class instance variables and stores them in an Array. This is to allow for the data object class to send any needed u... | def set_options(hash)
@collections ||= []
hash.each do |key, value|
instance_variable_set("@#{key}", value)
@collections << key if value.kind_of?(CollectionsFactory)
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(hash)\r\n hash.each { |k, v|\r\n # Create getters and setters\r\n self.class.attr_accessor(k)\r\n # Set value for created variable\r\n self.send(\"#{k}=\", v)\r\n }\r\n self.class.all.push(self)\r\n end",
"def initialize\n @collection={}\n end",
"def initialize\... | [
"0.6609248",
"0.6515485",
"0.6307325",
"0.621523",
"0.615191",
"0.61383194",
"0.61383194",
"0.61383194",
"0.61383194",
"0.61293703",
"0.6124861",
"0.6124547",
"0.6115768",
"0.6115768",
"0.6115768",
"0.6115768",
"0.6115768",
"0.6115768",
"0.6115768",
"0.6115768",
"0.61146194",... | 0.0 | -1 |
Use for setting a data object's class instance variable as a nested collection class. This method assumes your collection class name ends with "Collection". Therefore, the string you pass in its parameter is the first part of the class name. E.g., your collection class is called "DataObjectCollection", so, inside your ... | def collection(name)
Kernel.const_get("#{name}Collection").new(@browser)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_collection value\n instance_variable_set(collection_name, value)\n end",
"def set_collection_instance\n instance_variable_set(:\"@#{model_type.to_s.gsub('/', '__').pluralize}\", @resources)\n end",
"def set_collection_instance\n instance_variable_set(:\"@#{model_type.to_s.gsub('/', '__... | [
"0.64904046",
"0.6440576",
"0.6440576",
"0.64281964",
"0.63543",
"0.6299363",
"0.6272293",
"0.62131006",
"0.615326",
"0.6124549",
"0.60392296",
"0.5915849",
"0.58903664",
"0.5865865",
"0.58012974",
"0.57873106",
"0.5742627",
"0.57342726",
"0.5689846",
"0.5654925",
"0.5635986"... | 0.5148373 | 67 |
Items passed to this method are checked to ensure that the associated class instance variable is not nil. If it is, the script is aborted and an error is thrown. Use symbols separated by commas with this method. The symbol(s) should exactly match the name of the instance variable that must not be empty. NOTE: Currently... | def requires(*elements)
elements.each do |inst_var|
if inst_var.kind_of? Symbol
string="@#{inst_var.to_s}"
if instance_variable_get(string)==nil
raise "You've neglected to define a required variable for your #{self.class}.\n\nPlease ensure you always specify a value for #{string} whe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def class_variable_defined?(sym) end",
"def instance_variable(opts)\n opts = check_params(opts,[:instance_variable])\n super(opts)\n end",
"def validate_instance_vars\n flag = true\n self.instance_variables.each { |iv| flag = false if (self.instance_variable_get(iv) == nil && !iv.to_s.st... | [
"0.55488706",
"0.54775286",
"0.5469794",
"0.5437752",
"0.52681535",
"0.52368313",
"0.5214656",
"0.5186134",
"0.51348335",
"0.5132921",
"0.51042986",
"0.50777125",
"0.50387436",
"0.5032946",
"0.50233537",
"0.50087476",
"0.49781993",
"0.496753",
"0.4949717",
"0.49490774",
"0.49... | 0.49096 | 24 |
A shortcut method for filling out fields on a page. The method's first parameter is the page class that contains the fields you want to fill out. That is followed by the list of field name(s) (as Symbols). This method has a number of requirements: 1) The field name and the instance variable name in your data object mus... | def fill_out(page, *fields)
f_o_i true, nil, page, *fields
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fill_out(page, *fields)\n methods={\n 'Watir::TextField' => lambda{|p, f| p.send(f).fit(get f)},\n 'Watir::Select' => lambda{|p, f| p.send(f).pick!(get f)},\n 'Watir::Radio' => lambda{|p, f| p.send(f, get(f)) unless get(f)==nil }\n }\n fields.shuffle.each do |field|\n ... | [
"0.7537317",
"0.695396",
"0.68847597",
"0.6740197",
"0.6460676",
"0.6365686",
"0.6063819",
"0.6020217",
"0.59549004",
"0.591912",
"0.5908911",
"0.57603025",
"0.57333016",
"0.57215744",
"0.5689913",
"0.5674017",
"0.56228125",
"0.56205237",
"0.5566601",
"0.5565855",
"0.55542535... | 0.73711246 | 1 |
Use when you need to specify the order that the fields should be updated. | def ordered_fill(page, *fields)
f_o_i false, nil, page, *fields
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update!(**args)\n @field_name = args[:field_name] if args.key?(:field_name)\n @order_type = args[:order_type] if args.key?(:order_type)\n @sort_order = args[:sort_order] if args.key?(:sort_order)\n end",
"def set_order_fields(ar_values, ar_defaults, ar_ascdesc)\n @of_option... | [
"0.73239577",
"0.6604324",
"0.6357157",
"0.63338774",
"0.62369764",
"0.6223821",
"0.6215494",
"0.6158562",
"0.61510164",
"0.61467063",
"0.6132211",
"0.6132211",
"0.60800064",
"0.60780877",
"0.6053456",
"0.60514957",
"0.60422987",
"0.6023765",
"0.600803",
"0.59943646",
"0.5993... | 0.0 | -1 |
Same as fill_out, but used with methods that take a parameter to identify the target element... | def fill_out_item(name, page, *fields)
f_o_i true, name, page, *fields
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def element=(_arg0); end",
"def user_fill (element, data)\r\n begin\r\n key_processor(element)\r\n ****_fill(@selector, @locator, data)\r\n rescue Exception => e\r\n raise e.message\r\n raise e.backtrace.inspect\r\n end\r\n end",
"def element=(element); end",
"def get_elem_and_f... | [
"0.5905805",
"0.5813838",
"0.5752224",
"0.57482135",
"0.566211",
"0.54436004",
"0.5329991",
"0.52728146",
"0.52728146",
"0.52728146",
"0.52728146",
"0.52675956",
"0.5202291",
"0.5187857",
"0.514804",
"0.514804",
"0.5135194",
"0.5118066",
"0.5118066",
"0.50657463",
"0.49449825... | 0.45026368 | 81 |
Use instead of fill_out_item when you need to specify the order that the fields should be updated. | def ordered_item_fill(name, page, *fields)
f_o_i false, name, page, *fields
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_order_item\n \n end",
"def fill_out_item(name, page, *fields)\n f_o_i true, name, page, *fields\n end",
"def up_item \n order_op2(true, @item)\n end",
"def update\n @order_item.update_attributes(order_item_params)\n @order_items = @order.order_items\n end",
"def upda... | [
"0.7091839",
"0.663792",
"0.63053936",
"0.6046482",
"0.59861636",
"0.5983068",
"0.5980521",
"0.5974038",
"0.59021866",
"0.59003824",
"0.5840011",
"0.5840011",
"0.58225536",
"0.5802636",
"0.57861555",
"0.57788676",
"0.5770317",
"0.57618135",
"0.57544744",
"0.57544744",
"0.5754... | 0.6550206 | 2 |
Equivalent to ordered_fill, except that it's used in the context of a Data Object's edit method(s). As such, it requires the edit method's hash to be passed as its own first parameter. | def edit_fields(opts, page, *fields)
edit_item_fields opts, nil, page, *fields
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_fill\n end",
"def fill\n \t@fill\n end",
"def ordered_item_fill(name, page, *fields)\n f_o_i false, name, page, *fields\n end",
"def ordered_fill(page, *fields)\n f_o_i false, nil, page, *fields\n end",
"def fill(*args, &block)\n ary = self.to_a\n ary.fill *args, &block\... | [
"0.6152981",
"0.5553991",
"0.5484016",
"0.5368501",
"0.51676047",
"0.5116156",
"0.5094571",
"0.5009489",
"0.49598512",
"0.49309552",
"0.48295805",
"0.48136133",
"0.4799891",
"0.4796327",
"0.4781655",
"0.47407764",
"0.47381595",
"0.47351995",
"0.47276494",
"0.4719763",
"0.4712... | 0.0 | -1 |
Equivalent to ordered_item_fill, except that it's used in the context of a Data Object's edit method(s). As such, it requires the edit method's hash to be passed as its own first parameter. | def edit_item_fields(opts, name, page, *fields)
parse_fields(opts, name, page, *fields)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ordered_item_fill(name, page, *fields)\n f_o_i false, name, page, *fields\n end",
"def update_order_item\n \n end",
"def update_fill\n end",
"def edit_props(_item)\n {}\n end",
"def fill(model, item_path, args)\n fill_properties(model, item_path, args)\n end",
"def ... | [
"0.6235429",
"0.5772273",
"0.57348466",
"0.5414943",
"0.5389747",
"0.52992976",
"0.5192998",
"0.5187993",
"0.51463395",
"0.51343155",
"0.5119054",
"0.50927675",
"0.5059844",
"0.5013317",
"0.5011979",
"0.5011979",
"0.50112027",
"0.49999487",
"0.49955627",
"0.4984093",
"0.49828... | 0.0 | -1 |
This is a specialized method for use with any select list boxes that exist in the site you're testing and will contain unpredictable default values. Admittedly, this is a bit unusual, but one example would be be a "due date" list that changes its default selection based on today's date. You're going to want to do one o... | def get_or_select!(inst_var_sym, select_list)
value = instance_variable_get inst_var_sym
if value==nil
instance_variable_set inst_var_sym, select_list.selected_options[0].text
else
select_list.select value
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_or_select(hash_inst_var, select_list)\n if hash_inst_var==nil\n select_list.selected_options[0].text\n else\n select_list.select hash_inst_var\n hash_inst_var\n end\n end",
"def select\n cached_fetch(:select){default_select}\n end",
"def select_with_default_obje... | [
"0.6851508",
"0.6680143",
"0.66532165",
"0.6593154",
"0.6580418",
"0.5992219",
"0.5954685",
"0.5914034",
"0.58419466",
"0.58045405",
"0.57990193",
"0.5797739",
"0.57960916",
"0.57870847",
"0.5743054",
"0.5722698",
"0.5718249",
"0.5680567",
"0.567887",
"0.56716496",
"0.5656888... | 0.6946114 | 0 |
This method accomplishes the same thing as get_or_select! but is used specifically when the instance variable being used/updated is a Hash and you only need to update one of its key/value pairs. Pay close attention to the syntax differences between this method and get_or_select! First, note that the returned value of t... | def get_or_select(hash_inst_var, select_list)
if hash_inst_var==nil
select_list.selected_options[0].text
else
select_list.select hash_inst_var
hash_inst_var
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(struct_or_hash)\n struct_or_hash.each_pair do |key,value|\n method = \"#{key}=\".to_sym\n self.send(method, value) if self.respond_to?(method)\n end\n self\n end",
"def update(hash)\n raise(ArgumentError, \"Argument 'hash' must be a Hash.\") unless hash.is_a?(Hash)\n ... | [
"0.6106242",
"0.57399076",
"0.56935257",
"0.5685999",
"0.5672556",
"0.5590889",
"0.54329115",
"0.5362421",
"0.5355095",
"0.533251",
"0.53024805",
"0.5270968",
"0.5241519",
"0.52025676",
"0.52025676",
"0.52025676",
"0.52025676",
"0.52025676",
"0.52025676",
"0.52025676",
"0.520... | 0.5241314 | 13 |
Define this method in your data object when it has a parent, and that parent may periodically need to send it updated information about itself. | def update_from_parent(update)
raise %{
This method must be implemented in your data object
class if you plan to pass updates from a
parent object to the members of its
collections.
}
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare_refresh_before_update\n @parent_id_before = self.class.find(self.id).read_attribute(parent_id_column)\n end",
"def _parent; end",
"def has_changed_parent?\n self.parent_id_changed?\n end",
"def touch_parent\n self.parent.touch if parent\n end",
"def ensure_pa... | [
"0.6640496",
"0.66165036",
"0.64577186",
"0.641736",
"0.6399439",
"0.6364909",
"0.6276035",
"0.6270406",
"0.625676",
"0.6245648",
"0.6175689",
"0.6138122",
"0.61339575",
"0.61337304",
"0.6117112",
"0.6117112",
"0.6117112",
"0.6117112",
"0.6117112",
"0.6117112",
"0.6117112",
... | 0.68893355 | 0 |
======= Do not use this method directly. | def f_o_i(shuffle, name, page, *fields)
shuffle ? fields.shuffle! : fields
parse_fields(nil, name, page, *fields)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def private; end",
"def schubert; end",
"def refutal()\n end",
"def probers; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def implementation; end",
"def implementation; end",
"def custom; end",
"def custom; end",
"def private_method\n end",
"d... | [
"0.8252392",
"0.67681545",
"0.6726084",
"0.6719593",
"0.6671715",
"0.6671715",
"0.6671715",
"0.6671715",
"0.6656349",
"0.6656349",
"0.6543532",
"0.6543532",
"0.65095156",
"0.64012843",
"0.6323797",
"0.6318867",
"0.62757844",
"0.62757844",
"0.6230124",
"0.62047565",
"0.6201184... | 0.0 | -1 |
Do not use this method directly. | def parse_fields(opts, name, page, *fields)
fields.each do |field|
lmnt = page.send(*[field, name].compact)
var = opts.nil? ? instance_variable_get("@#{field}") : opts[field]
lmnt.class.to_s == 'Watir::Select' ? lmnt.pick!(var) : lmnt.fit(var)
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def private; end",
"def refutal()\n end",
"def private_method\n end",
"def implementation; end",
"def implementation; end",
"def schubert; end",
"def probers; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def internal; end",
"def custom; end",
... | [
"0.81749564",
"0.68876845",
"0.6858681",
"0.672525",
"0.672525",
"0.6687892",
"0.6585444",
"0.6568359",
"0.6568359",
"0.6568359",
"0.6568359",
"0.65178233",
"0.6508353",
"0.6508353",
"0.6470677",
"0.63410556",
"0.63141227",
"0.63141227",
"0.6311893",
"0.6311893",
"0.6311893",... | 0.0 | -1 |
Use this method in conjunction with your nested collection classes. The collections will notify their members about the passed parameters. Note: You must write a custom update_from_parent method in your data object that will know what to do with the parameter(s) passed to it. | def notify_collections *updates
@collections.each {|coll| instance_variable_get("@#{coll}").notify_members *updates }
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_from_parent(update)\n raise %{\n This method must be implemented in your data object\n class if you plan to pass updates from a\n parent object to the members of its\n collections.\n }\n end",
"def update!(**args)\n @added_parents = args[:added_parents] if args.key?(... | [
"0.7287591",
"0.67292494",
"0.64092076",
"0.62018067",
"0.613157",
"0.60565156",
"0.6010278",
"0.59763867",
"0.5961938",
"0.5934803",
"0.58548933",
"0.5803025",
"0.5775928",
"0.5771621",
"0.5767551",
"0.57454264",
"0.57449317",
"0.5737535",
"0.5722586",
"0.56717587",
"0.56491... | 0.5899027 | 10 |
GET /entradas/1 GET /entradas/1.xml | def show
@entradas = Entrada.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @entradas }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @entradas = Entrada.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @entradas }\n end\n end",
"def download_xml\n\t\turi = URI.parse(\"http://www.esmadrid.com/opendata/tiendas_v1_es.xml\")\n\t\tresponse = Net::HTTP.get_response(uri)\n\t... | [
"0.7061323",
"0.6945601",
"0.689327",
"0.6778746",
"0.67777807",
"0.6742282",
"0.67287076",
"0.6726005",
"0.6687699",
"0.66863966",
"0.66270137",
"0.6602745",
"0.65891427",
"0.65837246",
"0.6577213",
"0.6568468",
"0.65055186",
"0.6441277",
"0.6425853",
"0.64174986",
"0.639987... | 0.71619743 | 0 |
GET /entradas/new GET /entradas/new.xml | def new
@entradas = Entrada.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @entradas }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n @entrada = Entrada.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @entrada }\n end\n end",
"def new\n @entidade = Entidade.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @entidade... | [
"0.750877",
"0.74450177",
"0.7419376",
"0.7406951",
"0.7393879",
"0.73839754",
"0.73657215",
"0.7357614",
"0.73553085",
"0.73335063",
"0.73245776",
"0.7294583",
"0.72857344",
"0.7284219",
"0.7263424",
"0.7260114",
"0.7253674",
"0.7235877",
"0.7214056",
"0.7189867",
"0.7181234... | 0.76676595 | 0 |
POST /entradas POST /entradas.xml | def create
@entradas = Entrada.new(params[:entrada])
respond_to do |format|
if @entradas.save
flash[:notice] = 'LANÇAMENTO ENTRADA EFETUADO'
format.html { redirect_to(homes_path) }
format.xml { render :xml => @entradas, :status => :created, :location => @entradas }
else
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(uri, xml)\r\n req = Net::HTTP::Post.new(uri)\r\n req[\"content-type\"] = \"application/xml\"\r\n req.body = xml\r\n request(req)\r\n end",
"def create\n @entrada = Entrada.new(params[:entrada])\n\n respond_to do |format|\n if @entrada.save\n format.html { redirec... | [
"0.62639266",
"0.62356067",
"0.61845964",
"0.60700524",
"0.6051735",
"0.59288335",
"0.5914491",
"0.58594537",
"0.58487284",
"0.58299905",
"0.58166957",
"0.5815974",
"0.58082336",
"0.57998073",
"0.5765661",
"0.5762491",
"0.5759754",
"0.57429814",
"0.57043785",
"0.5691574",
"0.... | 0.6533152 | 0 |
PUT /entradas/1 PUT /entradas/1.xml | def update
@entradas = Entrada.find(params[:id])
respond_to do |format|
if @entradas.update_attributes(params[:entrada])
flash[:notice] = 'LANÇAMENTO ENTRADA ALTERADO.'
format.html { redirect_to(@entradas) }
format.xml { head :ok }
else
format.html { render :action ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put(uri, xml)\r\n req = Net::HTTP::Put.new(uri)\r\n req[\"content-type\"] = \"application/xml\"\r\n req.body = xml\r\n request(req)\r\n end",
"def update opts = {}\n opts[:headers] ||= {}\n opts[:headers]['Content-Type'] ||= 'text/xml'\n post 'update', opts\n end",
"def res... | [
"0.69834185",
"0.6891512",
"0.6691822",
"0.6121258",
"0.60664713",
"0.60394675",
"0.6000748",
"0.5985617",
"0.5967839",
"0.5933656",
"0.590277",
"0.5888278",
"0.5886702",
"0.5837349",
"0.57978743",
"0.5785754",
"0.57576865",
"0.57565486",
"0.57489926",
"0.57309973",
"0.571200... | 0.6197738 | 3 |
DELETE /entradas/1 DELETE /entradas/1.xml | def destroy
@entradas = Entrada.find(params[:id])
@entradas.destroy
respond_to do |format|
format.html{ redirect_to(homes_path) }
format.xml { head :ok }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @entrada = Entrada.find(params[:id])\n @entrada.destroy\n\n respond_to do |format|\n format.html { redirect_to(mngr_entradas_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n RestClient.delete \"#{REST_API_URI}/contents/#{id}.xml\" \n self\n end",
"def n... | [
"0.71183896",
"0.70800704",
"0.7068831",
"0.7021387",
"0.6967288",
"0.6966857",
"0.6933286",
"0.6916873",
"0.6902021",
"0.68703675",
"0.685086",
"0.68047154",
"0.68047154",
"0.6800856",
"0.67372394",
"0.6732682",
"0.67231053",
"0.67208207",
"0.66987675",
"0.66954094",
"0.6689... | 0.70902103 | 1 |
Outline 5m Intro In hasketball couldn't we just have done this instead of going deep into map def get_players game_hash.values.map do |team_info| team_info[:players] end.flatten > game_hash[:home][:players] + game_hash[:away][:players] end Yes! However if the data changed our code would break. We need to think about ho... | def red
colorize(:red)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def player_data\n players = []\n game_hash.each do |home_away, team_details|\n players << team_details[:players]\n end\n return players.flatten\nend",
"def game_hash\n { :home => {\n :team_name => \"Brooklyn Nets\",\n :colors => [\"Black\", \"White\"],\n :players => {\n \"Alan Anderson\" =>{... | [
"0.7386598",
"0.7376205",
"0.7373844",
"0.736783",
"0.736771",
"0.7364428",
"0.7332361",
"0.7330428",
"0.7269265",
"0.72675395",
"0.7260697",
"0.7248342",
"0.72460854",
"0.7243899",
"0.723621",
"0.72143316",
"0.7210056",
"0.72100544",
"0.71837246",
"0.7183036",
"0.71756035",
... | 0.0 | -1 |
Run cvdr query for patients who have had a risk assessment eligability is determined by age at time of assessment | def run_cvdr_risk_assess_query(filter)
filter = '1=1' if filter.blank?
query = Query.find_by_sql([
"select e.order_by_cvdr orderby, e.ethnicity_cvdr ethnicity, count(distinct c.patient_id) count\n"+
"from claims c\n"+
" left join claims_data d on d.id = c.id\n"+
" left join... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_cvdr_query(heading,filter)\n filter = '1=1' if filter.blank?\n query = Query.find_by_sql([\n \"select dbo.ethnicity_cvdr(p.ethnicity_id) ethnicity, '#{heading}' heading, count(c.id) count\\n\"+\n \"from claims c\\n\"+\n \" left join claims_data d on d.id = c.id\\n\"+\n ... | [
"0.6775541",
"0.5739233",
"0.5534905",
"0.55235",
"0.54737264",
"0.52981263",
"0.52107453",
"0.51919913",
"0.5179983",
"0.5170878",
"0.5114624",
"0.5066608",
"0.49660265",
"0.49580848",
"0.4955932",
"0.49481264",
"0.49461946",
"0.49372458",
"0.49145687",
"0.49009484",
"0.4894... | 0.7173858 | 0 |
Parameter: +value+:: string input to console | def initialize( value )
self.value = value
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def echo(value); end",
"def echo(value); end",
"def cli=(value); end",
"def echo(value)\n send_command([:echo, value])\n end",
"def user_input_value()\n puts \"Enter a value: \"\n value = gets.chomp.to_s\n return value\nend",
"def echo (input)\n input\n end",
"def echo(value)\n... | [
"0.67334706",
"0.67334706",
"0.666614",
"0.6392982",
"0.6336621",
"0.62604016",
"0.6210086",
"0.61866313",
"0.6119907",
"0.6095233",
"0.5991108",
"0.596197",
"0.58932",
"0.58923584",
"0.58870894",
"0.58828664",
"0.58695686",
"0.58634835",
"0.57708067",
"0.57681155",
"0.575878... | 0.0 | -1 |
Returns hash with flags as keys and arguments as values f argument >> f => arugment Parameter: +remove+:: Regexp of stuff to remove from argument | def get_flags( remove = nil )
# escape dashes for split
@value.gsub!(/\\\-/, "<dash>")
# Remove command, split by spaces
if remove.nil?
vars = @value.split(/\s-/)
else
vars = @value.gsub( remove, '' ).split(/\s-/)
end
# Hash to return
flags = Hash.new
# for each pair of arguments, place in Ha... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_flags(msg)\n msg.scan(/-(\\w+)\\s*([^-]+)?/)\n .uniq{ |e| e[0] }\n .map{ |k, v| [k, v.nil? ? nil : v.squish] }\n .to_h\n .symbolize_keys\nend",
"def extract_command_flags!(parameters)\n raw_command_flags = parameters.flatten.find_all { |arg| arg.start_with? \"--\" }\n par... | [
"0.5824933",
"0.5819659",
"0.57355857",
"0.57305515",
"0.56878215",
"0.5686714",
"0.5526422",
"0.5500887",
"0.54832506",
"0.5472093",
"0.5434607",
"0.5423765",
"0.540224",
"0.53611374",
"0.5332078",
"0.5306812",
"0.5306812",
"0.5263861",
"0.52573615",
"0.52493393",
"0.5245299... | 0.69216317 | 0 |
get_flags Returns array of variables split by spaces. _ are repalced with space. Parameter: +command+:: command to be removed from string prior to variable extraction. | def get_vars( command = nil )
# Remove command and split by space.
if command.is_a? NilClass
# No command, so just split
vars = self.value.split ' '
else
vars = self.value.sub( /#{command} ?/, '' ).split ' '
end
vars.map! do |element|
# Replace underscores
element.gsub!('_', ' ')
# Parse... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_flags( remove = nil )\n\n\t\t# escape dashes for split\n\t\t@value.gsub!(/\\\\\\-/, \"<dash>\")\n\n\t\t# Remove command, split by spaces\n\t\tif remove.nil?\n\t\t\tvars = @value.split(/\\s-/)\n\t\telse\n\t\t\tvars = @value.gsub( remove, '' ).split(/\\s-/)\n\t\tend\n\n\t\t# Hash to return\n\t\tflags = Hash.... | [
"0.677437",
"0.6241095",
"0.6149447",
"0.6149447",
"0.59495705",
"0.59292763",
"0.5900841",
"0.5778978",
"0.5711718",
"0.5572573",
"0.54367596",
"0.5308906",
"0.5306816",
"0.5291266",
"0.5277881",
"0.52610624",
"0.52498484",
"0.52341205",
"0.521454",
"0.5201909",
"0.5196954",... | 0.7049445 | 0 |
def menu_2 input = nil while input != "exit" puts "Press '1' for a quick description. Type 'menu' or 'list' to check out another store. Type 'exit' to exit. if input.to_i == 1 | def goodbye
puts "Safe travels!"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def menu_exit\n puts \"\\nPlease type 'Menu' to navigate to the menu, or 'Exit' to exit\"\n puts\"\\n-------------------------------------------------------------------------------------------\"\n input = gets.strip.downcase\n if input == \"menu\"\n menu_items\n elsif input == \"exit\"\n ... | [
"0.8311977",
"0.8019222",
"0.7848229",
"0.7715284",
"0.7711254",
"0.7674966",
"0.7637215",
"0.7627625",
"0.7582747",
"0.755939",
"0.75565946",
"0.7537525",
"0.7532865",
"0.7518804",
"0.75169826",
"0.7513054",
"0.7504034",
"0.7491208",
"0.74805415",
"0.74744797",
"0.7470289",
... | 0.0 | -1 |
TODO: This might be accessible from the rendering scope, which wouldn't be good. Figure out if this needs to be removed. | def load_helpers
paths = Dir.glob @site.helpers_path.join("**.rb")
HelperLoader.new(paths: paths).extend_instance(self)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rendered=(_arg0); end",
"def rendered; end",
"def rendered_format; end",
"def rendered_format; end",
"def render_calls; end",
"def view_renderer; end",
"def view_renderer; end",
"def rendering_options\n end",
"def renderer; end",
"def render\n # To be implemented.\n end",
"def rend... | [
"0.6734758",
"0.65610355",
"0.6535139",
"0.6535139",
"0.64332193",
"0.6288024",
"0.6288024",
"0.62429976",
"0.6208683",
"0.61731166",
"0.61498857",
"0.61498857",
"0.61498857",
"0.61498857",
"0.61498857",
"0.6089764",
"0.608868",
"0.6086577",
"0.60823286",
"0.6008946",
"0.5968... | 0.0 | -1 |
GET /share_users GET /share_users.json | def index
@share_users = ShareUser.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def share\n\n # Queries User by Tack Username\n item = ShareProfile.find(params[:share_profile_id])\n user = User.where({ username: params[:username] }).first\n\n # If user exists\n if item && user && user.id\n\n # Adds user to linked users\n item.linked_users << user\n\n # Updates Sh... | [
"0.73488945",
"0.7194028",
"0.6801358",
"0.67829275",
"0.6774161",
"0.6660985",
"0.6640296",
"0.6502691",
"0.64917284",
"0.63922036",
"0.6306559",
"0.6266041",
"0.6221967",
"0.6208254",
"0.61940163",
"0.61698866",
"0.6153805",
"0.6117428",
"0.6117398",
"0.6083847",
"0.6058798... | 0.72937405 | 1 |
GET /share_users/1 GET /share_users/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def share\n\n # Queries User by Tack Username\n item = ShareProfile.find(params[:share_profile_id])\n user = User.where({ username: params[:username] }).first\n\n # If user exists\n if item && user && user.id\n\n # Adds user to linked users\n item.linked_users << user\n\n # Updates Sh... | [
"0.72067124",
"0.7146753",
"0.7119718",
"0.6940541",
"0.66387784",
"0.65921736",
"0.651367",
"0.63808775",
"0.63776875",
"0.634454",
"0.631378",
"0.6306496",
"0.62871367",
"0.6284617",
"0.6283312",
"0.62640613",
"0.6231682",
"0.6176956",
"0.61291814",
"0.6122994",
"0.61070967... | 0.0 | -1 |
POST /share_users POST /share_users.json | def create
@share_user = ShareUser.new(share_user_params)
respond_to do |format|
if @share_user.save
format.html { redirect_to @share_user, notice: 'Share user was successfully created.' }
format.json { render :show, status: :created, location: @share_user }
else
format.html... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @user_share = UserShare.new(params[:user_share])\n if @user_share.insert(current_user.id)\n render json: @user_share, status: :created\n else\n render json: @user_share.errors, status: :unprocessable_entity\n end\n end",
"def share\n\n # Queries User by Tack Username\n i... | [
"0.74918485",
"0.74162614",
"0.7359967",
"0.6730021",
"0.6656618",
"0.6603353",
"0.63517565",
"0.63503736",
"0.6214381",
"0.6154856",
"0.6123745",
"0.61230737",
"0.6015433",
"0.60097766",
"0.5970783",
"0.59562206",
"0.5942581",
"0.59266406",
"0.58844745",
"0.5868589",
"0.5863... | 0.70680857 | 3 |
PATCH/PUT /share_users/1 PATCH/PUT /share_users/1.json | def update
respond_to do |format|
if @share_user.update(share_user_params)
format.html { redirect_to @share_user, notice: 'Share user was successfully updated.' }
format.json { render :show, status: :ok, location: @share_user }
else
format.html { render :edit }
format.jso... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @user_share = UserShare.find(params[:id])\n\n respond_to do |format|\n if @user_share.update_attributes(params[:user_share])\n format.html { redirect_to @user_share, notice: 'User share was successfully updated.' }\n format.json { head :no_content }\n else\n format... | [
"0.6920846",
"0.6533159",
"0.65174747",
"0.64933646",
"0.6312157",
"0.6295694",
"0.6256517",
"0.6218623",
"0.6218556",
"0.6215037",
"0.6207625",
"0.62015057",
"0.6190834",
"0.61903775",
"0.61903775",
"0.61752856",
"0.6140617",
"0.614007",
"0.6135823",
"0.6126525",
"0.6072917"... | 0.6791532 | 1 |
DELETE /share_users/1 DELETE /share_users/1.json | def destroy
@share_user.destroy
respond_to do |format|
format.html { redirect_to share_users_url, notice: 'Share user was successfully destroyed.' }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @user_share = UserShare.find(params[:id])\n @user_share.destroy\n\n respond_to do |format|\n format.html { redirect_to user_shares_url }\n format.json { head :no_content }\n end\n end",
"def delete_user_for_tenant(args = {}) \n delete(\"/tenants.json/#{args[:tenantId]}/users/... | [
"0.7457554",
"0.70546687",
"0.69386435",
"0.681555",
"0.6814426",
"0.68126345",
"0.6809501",
"0.6798605",
"0.6789914",
"0.67596567",
"0.6743911",
"0.67426634",
"0.6733153",
"0.6716762",
"0.6709729",
"0.6706167",
"0.66956764",
"0.6693896",
"0.66714644",
"0.6669154",
"0.6668935... | 0.73961973 | 1 |
Use callbacks to share common setup or constraints between actions. | def set_share_user
@share_user = ShareUser.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 share_user_params
params.require(:share_user).permit(:driver)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n... | [
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",... | 0.0 | -1 |
test that the 'for_category' method works | def test_feature_for_category
features = Feature.for_category(categories(:root).id, 99)
assert_equal(2, features.length)
assert_equal(true, features.include?(products(:persian)))
assert_equal(true, features.include?(products(:cow2)))
features = Feature.for_category(categories(:livestock).id, 99)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_passed_by_category(category)\n tests.by_category_name(category)\n end",
"def category; end",
"def set_category\n end",
"def has_categories? \n true\n end",
"def _category\n @_category ||= if category\n category\n elsif special_category\n special_categ... | [
"0.72616935",
"0.69063866",
"0.68122345",
"0.6669073",
"0.66170114",
"0.64175934",
"0.640196",
"0.63726133",
"0.63534564",
"0.63397866",
"0.6320818",
"0.6317749",
"0.6282083",
"0.6277704",
"0.624677",
"0.62357694",
"0.6209901",
"0.61985326",
"0.61964905",
"0.61961824",
"0.616... | 0.72666824 | 0 |
test that the 'for_static_page' method works basically the same as the 'for_category' method above, but for static pages | def test_feature_for_static_page
features = Feature.for_static_page(static_pages(:home).id, 99)
assert_equal(2, features.length)
assert_equal(true, features.include?(products(:optioner)))
assert_equal(true, features.include?(products(:cow2)))
features = Feature.for_static_page(static_pages(:aboutus).... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def should_display_about_and_features\n controller.controller_name == \"static_pages\"\n end",
"def should_have_correct_static_pages_links\n\tvisit root_path\n\tclick_link \"About\"\n\tpage.should have_selector 'title', text: full_title('About Us')\n\tclick_link \"Help\"\n\tpage.should have_selector 'title',... | [
"0.68735874",
"0.65604675",
"0.65017354",
"0.6421043",
"0.6204321",
"0.61512256",
"0.6124385",
"0.60597634",
"0.59955233",
"0.5970512",
"0.5968935",
"0.5968935",
"0.5968935",
"0.5946535",
"0.587916",
"0.5862247",
"0.581144",
"0.57564056",
"0.5745617",
"0.573739",
"0.5663539",... | 0.6940014 | 0 |
test that the 'for_layout' method works similar to the 'for_category' method above, but for the layout | def test_feature_for_layout
features = Feature.for_layout(99)
assert_equal(2, features.length)
assert_equal(true, features.include?(products(:optioner)))
assert_equal(true, features.include?(products(:cow3)))
# check that the correct number is given when the number to return is < the number of
# r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_layout(layout); end",
"def _conditional_layout?; end",
"def determine_layout\n 'akinu'\n end",
"def invalid_layout?(layout); end",
"def invalid_layout?(layout); end",
"def layout_children\n \n end",
"def do_layout(payload, layouts)\n end",
"def render_layout(output, layout, in... | [
"0.67871284",
"0.67183465",
"0.66343105",
"0.6602513",
"0.6602513",
"0.6593199",
"0.6570429",
"0.65600795",
"0.6556182",
"0.65549105",
"0.64628446",
"0.64628446",
"0.6434807",
"0.6348855",
"0.6339298",
"0.63178384",
"0.63096833",
"0.63096833",
"0.6307876",
"0.6266978",
"0.626... | 0.64807606 | 10 |
test that a description given to a feature overrides (if provided) the products description | def test_overriding_description
# first, a feature with no description assigned
features = Feature.for_static_page(static_pages(:aboutus).id)
assert_equal("Short description", features.first[:short_description])
# now, a feature with a description to override
features = Feature.for_category(categorie... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def try_to_get_product_description\n unless self.supply_item.nil?\n gotten_description = self.supply_item.get_description\n self.description = gotten_description unless (gotten_description == false or gotten_description.blank? or gotten_description.nil?)\n end\n end",
"def description\n desc ... | [
"0.59656394",
"0.587942",
"0.58644414",
"0.5852973",
"0.5829416",
"0.5804395",
"0.5789326",
"0.57739043",
"0.57720995",
"0.5770592",
"0.57246614",
"0.5695366",
"0.56161153",
"0.5609189",
"0.5558953",
"0.5555314",
"0.5540665",
"0.55264",
"0.55184907",
"0.55171055",
"0.54949254... | 0.77414656 | 0 |
Validates a Bearer token This method should return the full principal url, or false if the token was incorrect. | def validate_bearer_token(bearer_token)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_token(token)\n object_from_response(Code42::TokenValidation, :get, \"authToken/#{token.to_s}\")\n end",
"def check(request, response)\n auth = Http::Auth::Bearer.new(\n @realm,\n request,\n response\n )\n\n bearer_to... | [
"0.6986445",
"0.6962431",
"0.6884224",
"0.66639704",
"0.66567284",
"0.654704",
"0.6500449",
"0.6499687",
"0.64814454",
"0.64327896",
"0.64022934",
"0.638969",
"0.6384866",
"0.6327826",
"0.63148266",
"0.6307271",
"0.63028896",
"0.6296748",
"0.6276759",
"0.6276759",
"0.62716764... | 0.6490489 | 8 |
When this method is called, the backend must check if authentication was successful. The returned value must be one of the following [true, "principals/username"] [false, "reason for failure"] If authentication was successful, it's expected that the authentication backend returns a socalled principal url. Examples of a... | def check(request, response)
auth = Http::Auth::Bearer.new(
@realm,
request,
response
)
bearer_token = auth.token
if bearer_token.blank?
return [false, "No 'Authorization: Bearer' header found. Either the client did... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def authentication_successful?\n current_user.present?\n end",
"def authentication_successful?\n @user.present?\n end",
"def authentication_response_status\n authenticate_user.success? ? :ok : :unauthorized\n end",
"def authenticate\n authenticate_or_request_with_http_digest(REALM) do |u... | [
"0.61524093",
"0.61462736",
"0.5964628",
"0.5783895",
"0.5690838",
"0.5630399",
"0.5630399",
"0.5603501",
"0.5585095",
"0.5554351",
"0.5554351",
"0.5554351",
"0.5554351",
"0.5525431",
"0.5517561",
"0.5491214",
"0.548388",
"0.54707175",
"0.54631275",
"0.5460907",
"0.5458479",
... | 0.52848744 | 49 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.