query stringlengths 7 9.5k | document stringlengths 10 1.07M | negatives listlengths 19 19 | metadata dict |
|---|---|---|---|
Exports data to a CSV formatted file, using columns directly from a table table_name: name of the table exporting. Column names are pulled from it. data_array: an array of hashes (link from a find) | def csv_export_rawtable(table_name, data_array, options = {})
column_definitions = []
eval("#{table_name}.content_columns").each do |column|
column_definitions << [column.name, column.name]
end
csv_export(column_definitions, data_array, options)
end | [
"def export_data_arr_to_csv(data_arr)\n s = CSV.generate do |csv|\n csv << HEADERS_COLUMNS\n data_arr.each{ |row| csv << row }\n end\n File.write('./data/formatted_data.csv', s)\n @@file.close\n end",
"def output_csv(data)\n CSV.open(OUTPUT_FILE, 'wb') do |csv|\n data.each do |datum|\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Completes the transfer by creating inventory entries corresponding to the changes made to the source and destination inventories by the transfer items. | def complete!
now = Time.current
transaction do
transfer_items.each do |item|
source.present? && source.destock!(item, now, self)
destination.present? && destination.restock!(item, now, self)
end
update completed_at: now
end
end | [
"def move_inventory!(transfer)\n updated_quantities = {}\n item_validator = Errors::InsufficientAllotment.new(\"Transfer items exceeds \\\n the available inventory\")\n transfer.line_items.each do |line_item|\n inventory_item = inventory_items.fin... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Transfer is considered feasible only if all its items can be transferred, given current stock levels. Immediately returns true if the source is nil denoting an external source or if the source uses a stock gateway, which will not be queried. | def feasible?
return true if source.nil? || source.enable_gateway?
transfer_items.each do |item|
return false unless item.feasible?
end
true
end | [
"def feasible?\n return true if amount < 0 || source.nil? || !product.tracked_stock? || source.enable_gateway?\n inventory_item = source_item\n inventory_item.present? && inventory_item.available >= amount\n end",
"def can_transfer?\n return if sender.balance >= amount\n errors.add(:amount, IN... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Loads the given order items into the transfer. To keep track of inventory during the load, matching inventory items are preloaded and updated by each load_item! call. | def load!(order_items)
transaction do
products = order_items.map(&:product)
stock = source.inventory_items.for(products)
order_items.each do |order_item|
load_item!(order_item, stock)
end
end
end | [
"def load!\n transfer = find_or_create_transfer\n transfer.load!(order.items_waiting)\n end",
"def load!\n orders = @exchange_adapter.orders(direction: @direction)\n @subscriber_lock = true\n standartized_items = []\n orders[:data].each { |item| standartized_items << @exchange_adapter.class.s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new transfer item based on given order item, specifying the product, lot code, and amount, if not overridden by arguments. | def create_item_from(order_item, lot_code = nil, expires_at = nil, amount = nil)
transfer_items.create!(
order_item: order_item,
product: order_item.product,
lot_code: lot_code || order_item.lot_code,
expires_at: expires_at,
amount: amount || order_item.waiting
)
end | [
"def add_order(order_item, qty, order)\r\n if order_item == \"latte\"\r\n item = Item.new(\"latte\", $latte_cost, $latte_price)\r\n elsif order_item == \"tea\"\r\n item = Item.new(\"tea\", $tea_cost, $tea_price)\r\n elsif order_item == \"scones\"\r\n item = Item.new(\"scones\", $scones... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Duplicates given existing transfer items into this transfer, useful for creating return transfers. | def duplicate_items_from(items)
transaction do
items.each do |item|
transfer_items << item.dup
end
end
end | [
"def duplicate\n new_invoice = Invoice.create(self.attributes.except!('id', 'number', 'issue_date', 'sent_by_email', 'paid_amount'))\n self.items.each do |item|\n i = Item.create(item.attributes.except!('id'))\n new_invoice.items << i\n i.taxes << item.taxes\n end\n new_invoice.set_amount... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Loads a single order item from given stock into the transfer as one or more transfer items. Updates the stock accordingly. Attempts several strategies until one returns true to denote the item has been loaded or the item is left (partially) unloaded. | def load_item!(order_item, stock)
if !order_item.product.tracked_stock? || source.enable_gateway?
load_item_from_infinite_stock(order_item) && return
end
stock_items = stock.select { |item| item.product == order_item.product }
return false if stock_items.none?
if order_item.lot_code.present?
... | [
"def load_item_from_infinite_stock(order_item)\n create_item_from(order_item, order_item.order.number)\n true\n end",
"def load!\n transfer = find_or_create_transfer\n transfer.load!(order.items_waiting)\n end",
"def load!(order_items)\n transaction do\n products = order_items.map(&:produc... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Loading from infinite stock always succeeds. Order number is used as lot code for the transfer item. | def load_item_from_infinite_stock(order_item)
create_item_from(order_item, order_item.order.number)
true
end | [
"def load_item!(order_item, stock)\n if !order_item.product.tracked_stock? || source.enable_gateway?\n load_item_from_infinite_stock(order_item) && return\n end\n stock_items = stock.select { |item| item.product == order_item.product }\n return false if stock_items.none?\n\n if order_item.lot_co... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Loading an item by lot code selects an inventory item by code, and only loads the item if a match is found. | def load_item_by_lot_code(order_item, stock_items)
item = stock_items.find { |item| order_item.lot_code == item.code }
# If the order item has a serial number, try lot code part only.
if item.nil? && order_item.lot_code['-']
lot_code_part = order_item.lot_code.split('-').first
item = stock_item... | [
"def item_by_product_and_code(product, code)\n items_by_product(product).find_by(code: code)\n end",
"def source_item\n source.item_by_product_and_code(product, lot_code)\n end",
"def load_item( model_or_id, inventory, reset = nil )\r\n model = (model_or_id.is_a?(Integer)) ? @item_models.dig(mode... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
A function to read schedule .txt | def read_schedule2(fname)
ents=[]
File.open(fname,'r') do |f|
f.each_line do |line|
line.chomp!
a1,a2,a3,a4 = line.split(/\s*==\s*/)
hash={}
hash["1"] = a1
hash["2"] = a2
hash["3"] = a3
hash["4"] = a4
ents.pu... | [
"def get_schedule(input)\n\t \n @file = File.new(\"schedule.txt\", \"r\")\n @elements = Array.new\n\n @output_lines=\"Schedule for \"+ input+\": \\n\"\n\n @day=\"\"\n\n#search for course code input by user and extract schedule from the schedule.txt file\n while (@line = @file.gets)\n \n\tif @line.include? inp... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
A function to read time table | def read_time_table(fname)
ents=[]
File.open(fname,'r') do |f|
f.each_line do |line|
line.chomp!
a1,a2,a3,a4,a5 = line.split(/\s*==\s*/)
hash={}
hash["1"] = a1 # id
hash["2"] = a2 # start time
hash["3"] = a3 # end time
h... | [
"def timetable_info\n end",
"def getTimeTable(filename)\n timetable = TimeTable.parse(File.read(filename))\n timetable.updateCourseInfo(@courses[timetable.semester])\n timetable\n end",
"def get_time_and_corrected_gravity_data\n output = []\n @f.rewind\n until @f.eof \n cols = parse_r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /my_exams GET /my_exams.json | def index
@my_exams = MyExam.all
respond_to do |format|
format.html # index.html.erb
format.json { render json: @my_exams }
end
end | [
"def index\n @exams = Exam.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @exams }\n end\n end",
"def index\n @exams = @part.exams.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @exams }\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /my_exams/new GET /my_exams/new.json | def new
@my_exam = MyExam.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @my_exam }
end
end | [
"def new\n @exam = Exam.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @exam }\n end\n end",
"def new\n @exam_question = ExamQuestion.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @exam_questio... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /my_exams/1 DELETE /my_exams/1.json | def destroy
@my_exam = MyExam.find(params[:id])
@my_exam.destroy
respond_to do |format|
format.html { redirect_to my_exams_url }
format.json { head :no_content }
end
end | [
"def destroy\n @exam = Exam.find(params[:id])\n @exam.delete\n respond_to do |format|\n format.html { redirect_to exams_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @exam = Exam.find(params[:id])\n @exam.destroy\n\n respond_to do |format|\n format.html... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /checklocations/1 GET /checklocations/1.json | def show
@checklocation = Checklocation.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.json { render json: @checklocation }
end
end | [
"def get_location\n JSON.parse(get_results('/locations.json'), {symbolize_names: true})\n end",
"def get_location\n as_json(get_results('/locations.json'))\n end",
"def index\n @locs = Loc.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @locs }\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /checklocations/new GET /checklocations/new.json | def new
@checklocation = Checklocation.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @checklocation }
end
end | [
"def new\n @loc = current_user.locs.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @loc }\n end\n end",
"def new\n @location_have_location = LocationHaveLocation.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /checklocations POST /checklocations.json | def create
@checklocation = Checklocation.new(params[:checklocation])
respond_to do |format|
if @checklocation.save
format.html { redirect_to @checklocation, notice: 'Checklocation was successfully created.' }
format.json { render json: @checklocation, status: :created, location: @checklo... | [
"def checkin_location_set\n # create new location and link to actiontype\n at=Actiontype.find(params['actiontype'])\n loc=Location.create_from_params(params,at)\n\n log_message({actiontype: at, location: loc})\n head :ok\n end",
"def checkin\n # Set the User va... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /checklocations/1 PUT /checklocations/1.json | def update
@checklocation = Checklocation.find(params[:id])
respond_to do |format|
if @checklocation.update_attributes(params[:checklocation])
format.html { redirect_to @checklocation, notice: 'Checklocation was successfully updated.' }
format.json { head :no_content }
else
... | [
"def update\n render json: Location.update(params[\"id\"], params[\"location\"])\n end",
"def create\n @checklocation = Checklocation.new(params[:checklocation])\n\n respond_to do |format|\n if @checklocation.save\n format.html { redirect_to @checklocation, notice: 'Checklocation was success... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /checklocations/1 DELETE /checklocations/1.json | def destroy
@checklocation = Checklocation.find(params[:id])
@checklocation.destroy
respond_to do |format|
format.html { redirect_to checklocations_url }
format.json { head :no_content }
end
end | [
"def destroy\n @route_things_to_check.destroy\n respond_to do |format|\n format.html { redirect_to route_things_to_checks_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @roadblock_check.destroy\n respond_to do |format|\n format.html { redirect_to roadblock_che... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Construct a SQL literal. This is useful for sql that is too complex for Arel. | def sql_literal(value)
Arel::Nodes::SqlLiteral.new(value)
end | [
"def sql(string)\n ::Arel::Nodes::SqlLiteral.new(string)\n end",
"def static_sql(sql)\n sql.is_a?(String) ? sql : literal(sql)\n end",
"def sql_literal(expression)\n ::Arel.sql(expression.to_s).tap do |literal|\n SexyScopes.extend_expression(literal)\n SexyScopes... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Construct a SQL quoted string. This is used for fragments of SQL. | def sql_quoted(value)
Arel::Nodes.build_quoted(value)
end | [
"def escaped_sql\n sql % binds.reduce({}) { |a, (col, val)|\n a[col.to_sym] = if val.is_a? Array\n val.map { |x| @conn.quote x }.join(', ')\n else\n @conn.quote val\n end\n a\n }\n end",
"def... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
returns booleaan value duetoday or not | def due_today?
@due_date == Date.today
end | [
"def date_due\n dateOut + \n DAYS_BETWEEN_SEND_AND_LATEMSG1 +\n overdueGraceGranted + \n (canada? ? DAYS_EXTRA_FOR_CANADA : 0) + \n (apo? ? DAYS_EXTRA_FOR_APO : 0) \n end",
"def overdue?\n due_date.past?\n end",
"def due?\n due_week == Date.today.cweek ? true : false\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
it will push the todo in the todolist | def add(todo)
@todos.push(todo)
end | [
"def add(new_todo)\n @todos.push(new_todo)\n end",
"def add_todo(todo)\n todos << todo\n end",
"def add(data)\n @todos << data\n end",
"def addItem(item)\n @toDoListArray.push(item)\n end",
"def push\n end",
"def create\n @todo_item = @todo_list.todo_items.create(todo_item_pa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
it will return the todolist of overdue | def overdue
TodosList.new(@todos.filter { |todo| todo.overdue? })
end | [
"def overdue_todos(todos)\n todos.select{ |todo| todo.complete == false && todo.datetime < DateTime.now }\n end",
"def not_overdue\n FilterableList.new(tasks.clone.keep_if do |t|\n (!t.date || t.date < Date.today) && !t.done\n end)\n end",
"def client_tasks_overdue\n self.find_all... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
it will return the todolist of duetoday | def due_today
TodosList.new(@todos.filter { |todo| todo.due_today? })
end | [
"def dueToday\n dueTodayList = \"\"\n @toDoListArray.each do |e|\n if !e.status && e.dueDate == Date.today\n dueTodayList = dueTodayList + e.printItem + \" \"\n end\n end\n dueTodayList\n end",
"def due_later\n TodosList.new(@todos.filter { |todo| todo.due_later? })\n end",
"de... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
it will return the todolist of duelater | def due_later
TodosList.new(@todos.filter { |todo| todo.due_later? })
end | [
"def due_date_task_list\n @due_date_task_list\n end",
"def dueToday\n dueTodayList = \"\"\n @toDoListArray.each do |e|\n if !e.status && e.dueDate == Date.today\n dueTodayList = dueTodayList + e.printItem + \" \"\n end\n end\n dueTodayList\n end",
"def due_today\n TodosList.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /join_user_to_assistants GET /join_user_to_assistants.json | def index
@join_user_to_assistants = JoinUserToAssistant.all
end | [
"def create\n @join_user_to_assistant = JoinUserToAssistant.new(join_user_to_assistant_params)\n\n respond_to do |format|\n if @join_user_to_assistant.save\n format.html { redirect_to @join_user_to_assistant, notice: 'Join user to assistant was successfully created.' }\n format.json { rende... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /join_user_to_assistants POST /join_user_to_assistants.json | def create
@join_user_to_assistant = JoinUserToAssistant.new(join_user_to_assistant_params)
respond_to do |format|
if @join_user_to_assistant.save
format.html { redirect_to @join_user_to_assistant, notice: 'Join user to assistant was successfully created.' }
format.json { render :show, st... | [
"def index\n @join_user_to_assistants = JoinUserToAssistant.all\n end",
"def join\n classroom_id = params[:id]\n classroom = Classroom.find(classroom_id)\n group_id = classroom.gitlab_group_id\n user = User.find_by(gitlab_id: current_user.id)\n access = user.role == 'teacher' ? 50 : 20\n mem... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /join_user_to_assistants/1 PATCH/PUT /join_user_to_assistants/1.json | def update
respond_to do |format|
if @join_user_to_assistant.update(join_user_to_assistant_params)
format.html { redirect_to @join_user_to_assistant, notice: 'Join user to assistant was successfully updated.' }
format.json { render :show, status: :ok, location: @join_user_to_assistant }
... | [
"def approve_join_request\n authorize! :manage, :join_requests\n @user.site_role = \"mate\"\n respond_to do |format|\n if @user.save\n format.html { redirect_to join_requests_path, notice: \"#{@user.show_name} принят в команду\" }\n format.js { render json: { result: true }, status: 200 ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /join_user_to_assistants/1 DELETE /join_user_to_assistants/1.json | def destroy
@join_user_to_assistant.destroy
respond_to do |format|
format.html { redirect_to join_user_to_assistants_url, notice: 'Join user to assistant was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n @assist = Assist.find(params[:id])\n @assist.destroy\n\n respond_to do |format|\n format.html { redirect_to assists_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @guidances_user.destroy\n respond_to do |format|\n format.html { redirect_to gu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Save serialized attribute to cache. If serializer method or serialization block is not given, Ultracache tries to serialize the object by serializeing hash returned by its `as_json` method. | def save_cache(obj)
value = if @serializer_method
serializer.serialize(obj.send(@serializer_method))
elsif @serializing_block
serializer.serialize(@serializing_block.call(obj))
else
serializer.serialize(obj.as_json)
end
storage.set(key(obj), value)
value
... | [
"def cache_serialize(key, serializer: ActiveModel::ArraySerializer, json_opts: {}, &block)\n cache(key) { serialize(serializer: serializer, json_opts: json_opts, &block) }\n end",
"def save_cache(obj)\n return if @unless && obj.send(@unless)\n\n value = if @serializer_block\n @seriali... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Destroys cache from storage | def destroy_cache(obj)
storage.del(key(obj))
end | [
"def destroy\n delete_file @cached\n delete_file @etag\n delete_file @last_modified\n end",
"def delete_cache\n Rails.cache.delete(Service.get_key_cache_key)\n end",
"def delete_cache\r\n #TODO - a script in Tool folder does this\r\n end",
"def clear_cache\n @_data = n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates value of existing cache. Its behavior is same with that of `save_cache`. | def update_cache(obj)
save_cache(obj)
end | [
"def update_cache\n # Does nothing...up to subclasses to implement.\n end",
"def update_cache(obj)\n return unless @need_update\n delete_cache(obj)\n save_cache(obj)\n end",
"def set_cache\n cache_key = self.class.cache_key(self.key)\n Rails.cache.write(cache_key, self.ac... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a where condition that requires column to contain key Example: User.hstore_has_key(:properties, "favorite_color") | def hstore_has_key(column, key)
where("#{connection.quote_column_name(column)} ? :key", :key => key)
end | [
"def hstore_has_key(column, key)\n where(\"#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(column)} ? :key\", key: key)\n end",
"def hstore_has_any_keys(column, *keys)\n where(\"#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(column)} ?| ARRAY... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a where condition that requires column to contain all keys. Example: User.hstore_has_all_keys(:properties, "favorite_color", "favorite_song") User.hstore_has_all_keys(:properties, ["favorite_color", "favorite_song"]) | def hstore_has_all_keys(column, *keys)
where("#{connection.quote_column_name(column)} ?& ARRAY[:keys]", :keys => keys.flatten)
end | [
"def hstore_has_all_keys(column, *keys)\n where(\"#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(column)} ?& ARRAY[:keys]\", keys: keys.flatten)\n end",
"def hstore_has_any_keys(column, *keys)\n where(\"#{connection.quote_table_name(table_name)}.#{connection.quote_col... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a where condition that requires column to contain any keys. Example: User.hstore_has_any_keys(:properties, "favorite_color", "favorite_song") User.hstore_has_any_keys(:properties, ["favorite_color", "favorite_song"]) | def hstore_has_any_keys(column, *keys)
where("#{connection.quote_column_name(column)} ?| ARRAY[:keys]", :keys => keys.flatten)
end | [
"def hstore_has_any_keys(column, *keys)\n where(\"#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(column)} ?| ARRAY[:keys]\", keys: keys.flatten)\n end",
"def hstore_has_all_keys(column, *keys)\n where(\"#{connection.quote_table_name(table_name)}.#{connection.quote_col... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /step_types/1 GET /step_types/1.json | def show
@step_type = StepType.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.json { render json: @step_type }
end
end | [
"def new\n @step_type = StepType.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @step_type }\n end\n end",
"def create\n @step_type = StepType.new(params[:step_type])\n\n respond_to do |format|\n if @step_type.save\n format.html { red... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /step_types/new GET /step_types/new.json | def new
@step_type = StepType.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @step_type }
end
end | [
"def create\n @step_type = StepType.new(params[:step_type])\n\n respond_to do |format|\n if @step_type.save\n format.html { redirect_to @step_type, notice: 'Step type was successfully created.' }\n format.json { render json: @step_type, status: :created, location: @step_type }\n else\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /step_types POST /step_types.json | def create
@step_type = StepType.new(params[:step_type])
respond_to do |format|
if @step_type.save
format.html { redirect_to @step_type, notice: 'Step type was successfully created.' }
format.json { render json: @step_type, status: :created, location: @step_type }
else
forma... | [
"def step_type(step_type)\n @step.step_type = step_type\n end",
"def create\n @step = Step.new(step_params)\n @step.save\n render json: @step\n end",
"def new\n @step_type = StepType.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @step_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /step_types/1 PUT /step_types/1.json | def update
@step_type = StepType.find(params[:id])
respond_to do |format|
if @step_type.update_attributes(params[:step_type])
format.html { redirect_to @step_type, notice: 'Step type was successfully updated.' }
format.json { head :no_content }
else
format.html { render acti... | [
"def step_type(step_type)\n @step.step_type = step_type\n end",
"def update\n scenario = Scenario.find(params[:id])\n scenario.update(scenario_params)\n scenario.steps = []\n json_response(step_builder(scenario), status: :updated)\n rescue => e\n render json: {error: e.message}, status: 42... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /step_types/1 DELETE /step_types/1.json | def destroy
@step_type = StepType.find(params[:id])
@step_type.destroy
respond_to do |format|
format.html { redirect_to step_types_url }
format.json { head :no_content }
end
end | [
"def destroy\n @step1 = Step1.find(params[:id])\n @step1.destroy\n\n respond_to do |format|\n format.html { redirect_to step1s_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @step = RunStep.find(params[:id])\n @step.destroy\n\n respond_to do |format|\n format.js... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
added namespaces to make root element compliant with Intuit's expectation | def post_save xml, options={:mapping=>:_default}
# using REXML's element namespace method doesn't seem to set the namespace correctly...?
xml.root.add_attributes("xmlns"=>"http://schema.intuit.com/platform/fdatafeed/institutionlogin/v1")
xml.root.add_namespace "xsi", "http://www.w3.org/2001/XMLSchema-... | [
"def test_serialize_empty_namespace\n inner_props = {\n 200 => { '{}propertyname' => 'value' }\n }\n\n property = Tilia::Dav::Xml::Element::Response.new('uri', inner_props)\n\n xml = write('{DAV:}root' => { '{DAV:}response' => property })\n expecte... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Produces a random hipster paragraph. | def paragraph(sentence_count: 3, supplemental: false, random_sentences_to_add: 3)
sentences(number: resolve(sentence_count) + rand(random_sentences_to_add.to_i).to_i, supplemental: supplemental).join(' ')
end | [
"def paragraph\n ((1..(rand(3)+2)).map{sentence}).join(\" \")\n end",
"def random_paragraph\n sentences = []\n rand(4..6).times do\n sentences << random_sentence\n end\n\n sentences.join(\"\")\nend",
"def random_text(options={})\n min_paragraphs = (options[:min_paragraphs] || 3)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Produces a random hipster paragraph by characters. | def paragraph_by_chars(characters: 256, supplemental: false)
paragraph = paragraph(sentence_count: 3, supplemental: supplemental)
paragraph += " #{paragraph(sentence_count: 3, supplemental: supplemental)}" while paragraph.length < characters
"#{paragraph[0...characters - 1]}."
end | [
"def paragraph\n ((1..(rand(3)+2)).map{sentence}).join(\" \")\n end",
"def random_paragraph\n sentences = []\n rand(4..6).times do\n sentences << random_sentence\n end\n\n sentences.join(\"\")\nend",
"def generateHashtag\n \n begin\n text = Random.paragraphs(1)\n text = text.s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Toggle the visibility of the element, hide it if it's shown, show it if it's hidden. | def toggle
if style![:display] == :none
show
else
hide
end
end | [
"def toggle\n if visible?\n hide\n\n else\n show\n\n end\n end",
"def show\n @hidden = true\n toggle\n end",
"def link_to_visibility_toggle(options = {})\r\n options[:of] ||= '$(this.parentNode).next()'\r\n options[:default_visible] = true if options[:d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
returns all of the sales that match the given prod id | def sales
FarMar::Sale.all.find_all {|instance| instance.product_id == id}
end | [
"def sales\n FarMar::Sale.all.find_all { |sale| sale.product_id == id }\n end",
"def sales\n sales = FarMar::Sale.all\n sales.each do |var|\n if var.product_id == @product_id\n @sales_by_product << sales\n end\n end\n return @sales_by_product\n end",
"def sa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Init the status bar | def init_status_bar(menu)
status_bar = NSStatusBar.systemStatusBar
status_item = status_bar.statusItemWithLength(NSVariableStatusItemLength)
status_item.setMenu menu
status_item.setTitle "虾米同步状态"
@status_item = status_item
end | [
"def status_bar\n @status_bar ||= SimCtl::StatusBar.new(self)\n end",
"def create_status_bar\n status_bar.show_message(tr(\"Ready\"))\n end",
"def init_status_bar(menu)\n\t status_bar = NSStatusBar.systemStatusBar\n\t status_item = status_bar.statusItemWithLength(NSVariableStatusItemLength... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST to set username/station_id and redirect to SAML login | def login_creds
session_login["username"] = params.permit(:username)[:username]&.strip if allow_assert_username?
session_login["station_id"] = params.permit(:station_id)[:station_id]&.strip
redirect_to url_for_sso_host("/auth/samlva")
end | [
"def login\n request = OneLogin::RubySaml::Authrequest.new\n redirect_to(request.create(saml_settings))\n end",
"def initiate_saml_login\n javascript_redirect(saml_protected_page)\n end",
"def login\n redirect_to esdl_suite_service.auth_uri(new_nonce), allow_other_host: true\n end",
"def saml_l... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Packages needed to manage the server remotely and install applications. | def install_management
# Needed to play with the configuration database.
package 'debconf'
package 'debconf-utils'
# Keys for Debian packages.
package 'debian-archive-keyring'
# Fetch files via HTTP.
package 'curl'
package 'wget'
package 'dpkg-dev' # Builds packages from source.
... | [
"def install_packages\n return(interpreter.package_manager.install <<-HERE)\n # Core\n mysql-server\n mysql-client\n\n # Tools\n libcompress-zlib-perl\n mytop\n dbishell\n\n # Ruby drivers\n libmysql-ruby\n libdbd-mysql-ruby\n HERE\n end",
"def install_base... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Packages for all the database servers we could need. | def install_databases
package 'sqlite3'
package 'libsqlite3-dev'
package 'mysql-client'
package 'mysql-server'
package 'libmysql-dev', 'libmysqlclient-dev', /^libmysqlclient\d*-dev$/
package 'postgresql-client'
package 'libpq-dev'
# TODO: NoSQL stores.
end | [
"def servers\n package_types = %w(yum gem)\n status_types = %w(installed pending)\n\n servers = []\n servers_update = []\n packages_new = []\n server_packages = {}\n package_ids = {}\n Dir.glob(SERVER_FILES).sort.each do |yaml_file|\n server_yaml = YAML.load(File.open(yaml_file))\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /iscrivitis or /iscrivitis.json | def index
@iscrivitis = Iscriviti.all
end | [
"def index\n @ivrs = Ivr.order(:id).page(params[:page]).per(10)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @ivrs }\n end\n end",
"def index\n # Retrieve kpis templates from impac api.\n # TODO: improve request params to work for strong paramete... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /iscrivitis or /iscrivitis.json | def create
@iscriviti = Iscriviti.new(iscriviti_params)
respond_to do |format|
if @iscriviti.save
format.html { redirect_to @iscriviti, notice: "Iscriviti was successfully created." }
format.json { render :show, status: :created, location: @iscriviti }
else
format.html { ren... | [
"def create\n @isit = Isit.new(isit_params)\n\n respond_to do |format|\n if @isit.save\n format.html { redirect_to @isit, notice: 'Isit was successfully created.' }\n format.json { render :show, status: :created, location: @isit }\n else\n format.html { render :new }\n fo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /iscrivitis/1 or /iscrivitis/1.json | def update
respond_to do |format|
if @iscriviti.update(iscriviti_params)
format.html { redirect_to @iscriviti, notice: "Iscriviti was successfully updated." }
format.json { render :show, status: :ok, location: @iscriviti }
else
format.html { render :edit, status: :unprocessable_e... | [
"def update\n respond_to do |format|\n if @isit.update(isit_params)\n format.html { redirect_to @isit, notice: 'Isit was successfully updated.' }\n format.json { render :show, status: :ok, location: @isit }\n else\n format.html { render :edit }\n format.json { render json: @... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /iscrivitis/1 or /iscrivitis/1.json | def destroy
@iscriviti.destroy
respond_to do |format|
format.html { redirect_to iscrivitis_url, notice: "Iscriviti was successfully destroyed." }
format.json { head :no_content }
end
end | [
"def destroy\n @sitio = Sitio.find(params[:id])\n @sitio.destroy\n\n respond_to do |format|\n format.html { redirect_to sitios_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @isit.destroy\n respond_to do |format|\n format.html { redirect_to isits_url, notic... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Called directly on a keyed object, immediately dials and calls the keys specified as arguments. Returns the value found, or nil. A default cannot be specified. | def call(*lookup)
return KeyDialler.new(self, *lookup).call
end | [
"def call(default = nil)\n\t\t\tbegin\n\t\t\t\tvalue = @hash.dig(*@lookup)\n\t\t\trescue\n\t\t\t\tvalue = default\n\t\t\tend\n\t\t\treturn value\n\t\tend",
"def method_missing(key_name, *args)\n ans = get(key_name.to_s)\n ans = args[0] if ans == \"\" && args[0]\n ans\n end",
"def find(obj, key, defaul... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Encode the assertion into a request, including the signature. | def encode_and_sign_to_http_request(request, signing_secret)
authorization_info_b64 = Base64.strict_encode64(as_json)
request.headers[ASSERTION_HEADER_NAME] = authorization_info_b64
signature = OpenSSL::HMAC.digest("SHA256", signing_secret, authorization_info_b64)
request.headers[SIGNATU... | [
"def sign_assertion\n JWT.encode(claims, rsa_key, signing_algorithm)\n end",
"def sign_request(request_to_sign)\n # Sign it.\n hmac = OpenSSL::HMAC.digest(digest, configuration.secret, request_to_sign)\n\n # Don't forget to remove the newline from base64\n CGI.escape(Base64.encode6... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
tests the urlinfo method | def test_urlinfo
puts 'testing url info'
urlinfo = Topsy::Base.urlinfo("http://www.aycron.com")
assert urlinfo.class == Topsy::UrlInfo, "Class of urlinfo method doesn't return UrlInfo"
end | [
"def url_info(url, opts={}, cache_for=nil, parser = QAlexaUrlInfoParser)\n\t\toptions = {:response_groups=>VALID_URLINFO_RESPONSE_GROUPS}.merge(opts)\n\t\trequest_hash = {}\n\t\trequest_hash['Url'] = url\n\t\trequest_hash['ResponseGroup'] = response_groups_to_param(options[:response_groups])\n\t\tparams.each do |ke... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
This is a tad meh. We basically need to meta program our test methods as we'll want individual meths for each check so we get this easy to read in jenkins, but since we only know which lister to use once the program runs we'll have to extend ourselves lazily via class_eval which allows us to edit the class from within ... | def define_tests
@ours.each do |pkg|
their = @theirs.find { |x| x.name == pkg.name }
class_eval do
define_method("test_#{pkg.name}_#{pkg.version}") do
PackageVersionCheck.new(ours: pkg, theirs: their).run
end
end
end
end | [
"def define_tests\n Apt.update if Process.uid.zero? # update if root\n @lister.packages.each do |pkg|\n class_eval do\n define_method(\"test_#{pkg.name}_#{pkg.version}\") do\n PackageVersionCheck.new(pkg).run\n end\n end\n end\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Builds a Heading of +level+ | def build_heading level
heading = RDoc::Markup::Heading.new level, text
skip :NEWLINE
heading
end | [
"def build_heading level\n type, text, = get\n\n text = case type\n when :TEXT then\n skip :NEWLINE\n text\n else\n unget\n ''\n end\n\n RDoc::Markup::Heading.new level, text\n end",
"def heading(level, title)\n @io << @t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Builds a List flush to +margin+ | def build_list margin
p :list_start => margin if @debug
list = RDoc::Markup::List.new
until @tokens.empty? do
type, data, column, = get
case type
when :BULLET, :LABEL, :LALPHA, :NOTE, :NUMBER, :UALPHA then
list_type = type
if column < margin then
unget
... | [
"def build_list margin\n p :list_start => margin if @debug\n\n list = RDoc::Markup::List.new\n label = nil\n\n until @tokens.empty? do\n type, data, column, = get\n\n case type\n when *LIST_TOKENS then\n if column < margin || (list.type && list.type != type) then\n unget\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Builds a ListItem that is flush to +indent+ with type +item_type+ | def build_list_item indent, item_type = nil
p :list_item_start => [indent, item_type] if @debug
list_item = RDoc::Markup::ListItem.new item_type
until @tokens.empty? do
type, data, column = get
if column < indent and
not type == :NEWLINE and
(type != :INDENT or data < indent... | [
"def dump_list_item( markup, type=:BULLET )\n case type\n when :BULLET\n \"* \"+dump_markup_body(markup.body)\n when :NOTE\n # definition list\n markup.label+\"\\n : \"+dump_markup_body(markup.body)\n else\n markup.label+\" \"+dump_markup_body(markup.body)\n end... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Builds a Paragraph that is flush to +margin+ | def build_paragraph margin
p :paragraph_start => margin if @debug
paragraph = RDoc::Markup::Paragraph.new
until @tokens.empty? do
type, data, column, = get
case type
when :INDENT then
next if data == margin and peek_token[0] == :TEXT
unget
break
when :TEXT... | [
"def build_paragraph margin\n p :paragraph_start => margin if @debug\n\n paragraph = RDoc::Markup::Paragraph.new\n\n until @tokens.empty? do\n type, data, column, = get\n\n if type == :TEXT and column == margin then\n paragraph << data\n\n break if peek_token.first == :BREAK\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Builds a Verbatim that is flush to +margin+ | def build_verbatim margin
p :verbatim_begin => margin if @debug
verbatim = RDoc::Markup::Verbatim.new
until @tokens.empty? do
type, data, column, = get
case type
when :INDENT then
if margin >= data then
unget
break
end
indent = data - margin
... | [
"def build_verbatim margin\n p :verbatim_begin => margin if @debug\n verbatim = RDoc::Markup::Verbatim.new\n\n min_indent = nil\n generate_leading_spaces = true\n line = ''.dup\n\n until @tokens.empty? do\n type, data, column, = get\n\n if type == :NEWLINE then\n line << data\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Skips a token of +token_type+, optionally raising an error. | def skip token_type, error = true
type, data, = get
return unless type # end of stream
return @current_token if token_type == type
unget
raise ParseError, "expected #{token_type} got #{@current_token.inspect}" if
error
end | [
"def skip token_type, error = true\n type, = get\n return unless type # end of stream\n return @current_token if token_type == type\n unget\n raise ParseError, \"expected #{token_type} got #{@current_token.inspect}\" if error\n end",
"def skip_token(tk)\n if tk.is_a? Symbol\n current_tk.wr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Calculates the column and line of the current token based on +offset+. | def token_pos offset
[offset - @line_pos, @line]
end | [
"def token_pos(byte_offset) # :nodoc:\n [byte_offset - @line_pos, @line]\n end",
"def token_pos byte_offset # :nodoc:\n [byte_offset - @line_pos, @line]\n end",
"def get_line_and_column_from_chunk(offset)\n if offset.zero?\n return [@chunk_line, @chunk_column]\n end\n\n string =\n off... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
:callseq: ratio obj > new_obj Performs a symbolic power between a symbolic rational and `obj`, returning a new symbolic object if the operation creates a new tree branch, or a symbolic number if `obj` is a SymDesc::Number. Simplification is automatic. If b is not a symbolic object, a conversion is attempted | def **(b)
b = b.symdescfy
case b
when Infinity
b
when Int
return Ratio.new(@numerator ** b.value, @denominator ** b.value)
else
super
end
end | [
"def coerce(other)\n if other.is_a? Numeric\n [Rational.new(other, 1), self]\n else\n puts \"(Rational failed to coerce object of type #{other.class})\"\n super\n end\n end",
"def eval_object(v)\n a = v['a']\n b = v['b']\n case v['operation']\n when \"+\" then a+b\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
:callseq: ratio == obj > true or false Returns true only if the `obj` is a SymDesc::Ratio or a Float or a Rational and it represents the same numeric value | def ==(b)
case b
when Rational, Ratio
(@numerator == b.numerator) &&
(@denominator == b.denominator)
when Float
self == b.symdescfy
else
false
end
end | [
"def ==(rational)\n self.numerator * rational.denominator == self.denominator * rational.numerator\n end",
"def ==(rational)\n \t@numerator * rational.denominator == @denominator * rational.numerator\n end",
"def ==(rational)\n end",
"def == (other)\n if other.kind_of?(Rational)\n @numerator ==... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
:callseq: to_s > string to_s(str_io) > str_io If no argument is provided, it returns a string representation of the fraction. If a StringIO object is passed, the string representation is appended to the buffer and the buffer is returned. | def to_s(io = nil)
if io
__io_append(io, @numerator, DIV_ID, @denominator)
else
return "#{@numerator}/#{@denominator}"
end
io
end | [
"def to_s(io = nil)\n \tif io \n __io_append(io,@numerator, DIV_ID, @denominator) \n else\n return \"#{@numerator}/#{@denominator}\"\n end\n io\n end",
"def to_s(io = nil)\n _io = io || __new_io(get_size)\n case argument\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get the normalized value for the key. If localization is in play the current locale will be appended to the key in MongoDB dot notation. FIXME (Did). This version DOES NOT USE ::I18n.locale directly. See the localized.rb file for more explanation. | def normalized_key(name, serializer)
# serializer && serializer.localized? ? "#{name}.#{::I18n.locale}" : name
serializer&.localized? ? "#{name}.#{::Mongoid::Fields::I18n.locale}" : name
end | [
"def normalized_key(name, serializer)\n serializer && serializer.localized? ? \"#{name}.#{::Mongoid::Localizer.locale}\" : name\n end",
"def normalized_key(name, serializer)\n serializer && serializer.localized? ? \"#{name}.#{::I18n.locale}\" : name\n end",
"def localized_key(name, serializer)\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
compile all TeX files in dir | def compile(dir)
savedir = Dir.pwd
Dir.chdir(dir)
# 中間ファイル削除
clean
# 個別ファイルコンパイル
Dir::glob("*.pdf").each do |file|
next if "nzmath_doc" == file[0...-4]
tex_compile(file[0...-4])
end
header_footer = ["header_overview.tex", "header_basic_util.tex", "header_class.tex",
"header_function.tex",... | [
"def compile()\n a = Dir[\"src/mjml/templates/**/*.mjml\"]\n for file in a\n loc = file.split('/', 1).last.chomp('.mjml')\n name = file.split('#{loc}').last.chomp('.mjml')\n source = name.split('/').last\n `mjml #{name}.mjml -o src/html/#{source}.html`\n puts \"Successfully ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
This method create all the join table given by the filter and the saving associated with each | def create_join_table_gas(filter, all_savings)
filter.each_with_index do |contract, index|
JoinTableGasSimulationContract.create(gas_simulation: self, gas_contract: contract, savings: all_savings[index])
end
end | [
"def create_join_table_mobil(filter, all_savings)\n filter.each_with_index do |contract, index|\n JoinTableMobilContract.create(mobil_simulation: self, mobil_contract: contract, savings: all_savings[index])\n end\n end",
"def create_table_joins(klass)\n if join_tables = klass.ann(:self, :join_table... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Determines whether or not any transition states exist given a beginning state and input symbol pair. | def has_transition?(state, symbol)
return false unless @transitions.include? state
@transitions[state].has_key? symbol
end | [
"def has_transition?(state, symbol)\n return false unless @transitions.has_key? state\n if @transitions[state].has_key? symbol\n actions = @transitions[state][symbol]\n return false if actions['pop'] && @stack.last != actions['pop']\n return true\n else\n return false\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Determines if a given state is an accept state. | def accept_state?(state)
@accept.include? state
end | [
"def is_accept_state?(state)\n @accept.include? state.to_s\n end",
"def accepted?\n state == 'accepted'\n end",
"def accepted?\n self.state == ACCEPTED\n end",
"def accepting?\n !!@data[:accepting]\n end",
"def get_accept_state_reachable\n return @accept_state_reachable\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Pass on certain authorize_params to the Slack authorization GET request. See | def authorize_params
super.tap do |params|
%w(scope team redirect_uri).each do |v|
if !request.params[v].to_s.empty?
params[v.to_sym] = request.params[v]
end
end
log(:debug, "Authorize_params #{params.to_h}")
end
end | [
"def authorize_params\n super.tap do |params|\n %w[display scope auth_type].each do |v|\n if request.params[v]\n params[v.to_sym] = request.params[v]\n end\n end\n end\n end",
"def authorize_params\n super.tap do |params|\n %w... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Preload additional api calls with a pool of threads. | def preload_data_with_threads(num_threads)
return unless num_threads > 0
preload_methods = active_methods.concat(options[:additional_data].keys)
log :info, "Preloading (#{preload_methods.size}) data requests using (#{num_threads}) threads."
work_q = Queue.new
preload_methods.each... | [
"def fetch_apis_asynchronously \n threads = []\n threads << Thread.new { @resp1 = RestClient.get 'https://reqres.in/api/unknown' }\n threads << Thread.new { @resp2 = RestClient.get 'https://reqres.in/api/products' }\n threads.each { |thr| thr.join } \n end",
"de... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Define methods for addional data from :additional_data option | def define_additional_data
hash = options[:additional_data]
if !hash.to_h.empty?
hash.each do |k,v|
define_singleton_method(k) do
instance_variable_get(:"@#{k}") ||
instance_variable_set(:"@#{k}", v.respond_to?(:call) ? v.call(env) : v)
end
... | [
"def additional_data=(value)\n @additional_data = value\n end",
"def additional_data_options\n return @additional_data_options\n end",
"def additional_data\n return @additional_data\n en... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Is this a workspace app token? | def is_app_token?
auth['token_type'].to_s == 'app'
end | [
"def is_app_token?\n case\n when params['token_type'] == 'app' || token.to_s[/^xoxa/]\n true\n when token.to_s[/^xoxp/]\n false\n else\n nil\n end\n end",
"def token_is_for_master?\n token_account['name'] == 'mas... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Scopes come from at least 3 different places now. The classic :scope field (string) New workshop token :scopes field (hash) Separate call to apps.permissions.users.list (array) This returns hash of workspace scopes, with classic & new identity scopes in :identity. Lists of scopes are in array form. | def all_scopes
@all_scopes ||=
{'identity' => (auth['scope'] || apps_permissions_users_list[user_id].to_h['scopes'].to_a.join(',')).to_s.split(',')}
.merge(auth['scopes'].to_h)
end | [
"def user_scopes_all\n %w(calls:read calls:write\n channels:history channels:read channels:write\n chat:write\n dnd:read dnd:write\n emoji:read\n files:read files:write\n groups:history groups:read groups:write\n im:history im:read im:write\n links:read links:write... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Determine if given scopes exist in current authorization. Scopes is hash where key == scope type val == array or string of individual scopes. | def has_scope?(**scopes_hash)
scopes_hash.detect do |section, scopes|
test_scopes = case
when scopes.is_a?(String); scopes.split(',')
when scopes.is_a?(Array); scopes
else raise "Scope must be a string or array"
end
test_scopes.detect do |scope|
... | [
"def has_scope?(*scopes, accept_all: true)\n acceptable = scopes\n acceptable += [:all] if accept_all\n token&.acceptable?(acceptable)\n end",
"def sufficent_scope?(req_scopes)\n if req_scopes.blank?\n # if no any scopes required, the scopes of token is sufficient.\n true\n else\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /reqcargos GET /reqcargos.json | def index
@reqcargos = Reqcargo.all
end | [
"def list_tenants_for_circles(args = {}) \n get(\"/tenants.json/circles\", args)\nend",
"def list_tenants_for_circle(args = {}) \n get(\"/tenantcircles.json/tenants\", args)\nend",
"def index\n @oc_requests = OcRequest.all.order(id: :desc).page(params[:page]).per(300)\n end",
"def get_clients_by_devices(a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /reqcargos POST /reqcargos.json | def create
@reqcargo = Reqcargo.new(reqcargo_params)
respond_to do |format|
if @reqcargo.save
format.html { redirect_to @reqcargo, notice: 'Reqcargo was successfully created.' }
format.json { render :show, status: :created, location: @reqcargo }
else
format.html { render :ne... | [
"def add_tenant_circle(args = {}) \n post(\"/tenantcircles.json/\", args)\nend",
"def do_coaps_posted_03\n # get the Base64 of the incoming signed request\n body = IO.read(\"spec/files/vr_00-D0-E5-F2-00-03.vrq\")\n\n env = Hash.new\n env[\"SSL_CLIENT_CERT\"] = cbor_clientcert_03\n env[\"H... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /reqcargos/1 DELETE /reqcargos/1.json | def destroy
@reqcargo.destroy
respond_to do |format|
format.html { redirect_to reqcargos_url, notice: 'Reqcargo was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def delete\n RestClient.delete \"#{@uri}/api/requests/request/#{@data['requestId']||@data['id']}\"\n puts ' Deleted request: '.red + \"#{@data['requestId']||@data['id']}\".light_blue\n end",
"def delete_tenant_circle(args = {}) \n delete(\"/tenantcircles.json/#{args[:circleId]}\", args)\nend",
"de... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Initializes a new AttributeGroupData instance with the specified name and an empty set of rows. +name+:: The name of the attribute group whose data is being represented. | def initialize(name)
@name = name
@rows = Array.new
end | [
"def initialize(name)\n @name = name\n @groups = Levels::KeyValues.new\n end",
"def build!(data_set_name)\n interface(data_set_name).create_empty_data_set\n library[data_set_name] = DataSet.new(data_set_name, interface(data_set_name))\n end",
"def new_group(group_data)\n [... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns a tabular string representation of the attribute group's data. If +column_names+ is non+nil+, only returns data for the columns specified; otherwise returns data for all columns. +column_names+:: An array of columsn to display data for. +format+:: The format to output data in. Must be either :text or :html. If ... | def to_table(column_names=nil, format="text")
require 'tabular'
stringio = StringIO.new;
$stderr.puts "Request for #{@name} data returned #{@rows.length} #{@rows.length != 1 ? "rows" : "row"}."
if rows.length > 0
# If no column names were specified, use all the columns in the first row (in alpha... | [
"def column_format(method, options = {})\n options[:formatter] = procify(options[:formatter]) if options[:formatter] && options[:formatter].is_a?(Symbol)\n @attr_formats = (@attr_formats || default_formats).deep_merge({method.to_s => options})\n end",
"def format_table_datasource\n unless ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the specified attribute group's data from the agent/service_point specified and returns a new AttributeGroupData object which contains that data. +agent_address+:: The address of the machine on which the agent resides. +service_point+:: The service point of the agent from which to collect the data. +username+:: Th... | def get_attribute_group_data(agent_address, service_point, username, password, attribute_group, subnodes, port=1920)
require 'net/http'
uri = URI("http://#{agent_address}:#{port}///#{service_point}/#{service_point}")
body = "<REPORT><SQLTABLE NULLATTROUTPUT=\"Y\"><TABLENAME>#{attribute_group}</TABLENAME><SUBNODE... | [
"def parse_args(args)\n require 'ostruct'\n require 'optparse'\n\n parser = OptionParser.new\n options = OpenStruct.new\n\n options.output = STDOUT\n options.format = :text\n options.columns = nil\n options.subnodes = [ ]\n\n parser.banner = \"Usage: #{$0} [options] agent_address service_point username pas... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Parses the specified arguments (presumably ARGV), returning the agent address, service point, username, password, and attribute group that were specified on the command line, in addition a list of columns and subnodes in an OpenStruct object. +args+:: The arguments to parse. These presumably came from the commandline. | def parse_args(args)
require 'ostruct'
require 'optparse'
parser = OptionParser.new
options = OpenStruct.new
options.output = STDOUT
options.format = :text
options.columns = nil
options.subnodes = [ ]
parser.banner = "Usage: #{$0} [options] agent_address service_point username password attribute_gr... | [
"def parse_cmd_arguments( args ) # {{{\n\n options = OpenStruct.new\n options.debug = false\n options.quiet = false\n\n # Define default options\n\n pristine_options = options.dup\n\n opts = OptionParser.new do |opts|\n opts.banner = \"Usage: #{__FILE__.to_s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /produtividades POST /produtividades.xml | def create
@produtividade = Produtividade.new(params[:produtividade])
respond_to do |format|
if @produtividade.save
format.html { redirect_to(@produtividade, :notice => 'Produtividade was successfully created.') }
format.xml { render :xml => @produtividade, :status => :created, :location... | [
"def create\n @produto = Produto.new(params[:produto])\n\n respond_to do |format|\n if @produto.save\n format.html { redirect_to(@produto, :notice => 'Produto was successfully created.') }\n format.xml { render :xml => @produto, :status => :created, :location => @produto }\n else\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /webs POST /webs.json | def create
@web = Web.new(web_params)
respond_to do |format|
if @web.save
format.html { redirect_to @web, notice: 'Web was successfully created.' }
format.json { render :show, status: :created, location: @web }
else
format.html { render :new }
format.json { render js... | [
"def create\n @web = Web.new(params[:web])\n\n respond_to do |format|\n if @web.save\n format.html { redirect_to @web, :notice => 'Сетка расписания успешно создана' }\n format.json { render :json => @web, :status => :created, :location => @web }\n else\n format.html { render :ac... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /webs/1 DELETE /webs/1.json | def destroy
@web.destroy
respond_to do |format|
format.html { redirect_to webs_url, notice: 'Web was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n @web = Web.find(params[:id])\n @web.destroy\n\n respond_to do |format|\n format.html { redirect_to webs_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @web = Web.find(params[:id])\n @web.destroy\n\n respond_to do |format|\n format.html { redirect_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Provides operations to manage the defaultManagedAppProtections property of the microsoft.graph.deviceAppManagement entity. | def default_managed_app_protections()
return MicrosoftGraph::DeviceAppManagement::DefaultManagedAppProtections::DefaultManagedAppProtectionsRequestBuilder.new(@path_parameters, @request_adapter)
end | [
"def default_managed_app_protections=(value)\n @default_managed_app_protections = value\n end",
"def default_managed_app_protections\n return @default_managed_app_protections\n end",
"def ios_managed_app_protections()\n return MicrosoftGraph::De... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Provides operations to manage the iosManagedAppProtections property of the microsoft.graph.deviceAppManagement entity. | def ios_managed_app_protections()
return MicrosoftGraph::DeviceAppManagement::IosManagedAppProtections::IosManagedAppProtectionsRequestBuilder.new(@path_parameters, @request_adapter)
end | [
"def ios_managed_app_protections=(value)\n @ios_managed_app_protections = value\n end",
"def ios_managed_app_protections\n return @ios_managed_app_protections\n end",
"def default_managed_app_protections()\n return MicrosoftGraph::DeviceAppManag... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Provides operations to manage the managedAppPolicies property of the microsoft.graph.deviceAppManagement entity. | def managed_app_policies()
return MicrosoftGraph::DeviceAppManagement::ManagedAppPolicies::ManagedAppPoliciesRequestBuilder.new(@path_parameters, @request_adapter)
end | [
"def get_managed_app_policies()\n return MicrosoftGraph::Me::GetManagedAppPolicies::GetManagedAppPoliciesRequestBuilder.new(@path_parameters, @request_adapter)\n end",
"def managed_app_policies=(value)\n @managed_app_policies = value\n end",
"def app_managemen... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Provides operations to manage the managedAppRegistrations property of the microsoft.graph.deviceAppManagement entity. | def managed_app_registrations()
return MicrosoftGraph::DeviceAppManagement::ManagedAppRegistrations::ManagedAppRegistrationsRequestBuilder.new(@path_parameters, @request_adapter)
end | [
"def managed_app_registrations=(value)\n @managed_app_registrations = value\n end",
"def managed_app_registrations()\n return MicrosoftGraph::Me::ManagedAppRegistrations::ManagedAppRegistrationsRequestBuilder.new(@path_parameters, @request_adapter)\n end",
"de... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Provides operations to manage the managedAppStatuses property of the microsoft.graph.deviceAppManagement entity. | def managed_app_statuses()
return MicrosoftGraph::DeviceAppManagement::ManagedAppStatuses::ManagedAppStatusesRequestBuilder.new(@path_parameters, @request_adapter)
end | [
"def managed_app_statuses=(value)\n @managed_app_statuses = value\n end",
"def managed_app_statuses\n return @managed_app_statuses\n end",
"def get_managed_app_diagnostic_statuses()\n return MicrosoftGraph::Me::GetManagedAppDiagnosticStatuses::G... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Provides operations to manage the managedEBooks property of the microsoft.graph.deviceAppManagement entity. | def managed_e_books()
return MicrosoftGraph::DeviceAppManagement::ManagedEBooks::ManagedEBooksRequestBuilder.new(@path_parameters, @request_adapter)
end | [
"def managed_e_books=(value)\n @managed_e_books = value\n end",
"def managed_apps=(value)\n @managed_apps = value\n end",
"def managed_devices=(value)\n @managed_devices = value\n end",
"def managed_e_books\n return @... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Provides operations to manage the mdmWindowsInformationProtectionPolicies property of the microsoft.graph.deviceAppManagement entity. | def mdm_windows_information_protection_policies()
return MicrosoftGraph::DeviceAppManagement::MdmWindowsInformationProtectionPolicies::MdmWindowsInformationProtectionPoliciesRequestBuilder.new(@path_parameters, @request_adapter)
end | [
"def mdm_windows_information_protection_policies=(value)\n @mdm_windows_information_protection_policies = value\n end",
"def windows_information_protection_policies()\n return MicrosoftGraph::DeviceAppManagement::WindowsInformationProtectionPolicies::WindowsInformationProt... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Provides operations to manage the mobileAppCategories property of the microsoft.graph.deviceAppManagement entity. | def mobile_app_categories()
return MicrosoftGraph::DeviceAppManagement::MobileAppCategories::MobileAppCategoriesRequestBuilder.new(@path_parameters, @request_adapter)
end | [
"def mobile_app_categories=(value)\n @mobile_app_categories = value\n end",
"def mobile_app_categories\n return @mobile_app_categories\n end",
"def categories()\n return MicrosoftGraph::DeviceAppManagement::MobileApps::Item::Categories::... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Provides operations to manage the mobileAppConfigurations property of the microsoft.graph.deviceAppManagement entity. | def mobile_app_configurations()
return MicrosoftGraph::DeviceAppManagement::MobileAppConfigurations::MobileAppConfigurationsRequestBuilder.new(@path_parameters, @request_adapter)
end | [
"def mobile_app_configurations=(value)\n @mobile_app_configurations = value\n end",
"def targeted_managed_app_configurations()\n return MicrosoftGraph::DeviceAppManagement::TargetedManagedAppConfigurations::TargetedManagedAppConfigurationsRequestBuilder.new(@path_parameter... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Provides operations to manage the mobileApps property of the microsoft.graph.deviceAppManagement entity. | def mobile_apps()
return MicrosoftGraph::DeviceAppManagement::MobileApps::MobileAppsRequestBuilder.new(@path_parameters, @request_adapter)
end | [
"def mobile_apps=(value)\n @mobile_apps = value\n end",
"def device_app_management()\n return MicrosoftGraph::DeviceAppManagement::DeviceAppManagementRequestBuilder.new(@path_parameters, @request_adapter)\n end",
"def targeted_mobile_apps=(value)\n @tar... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Provides operations to call the syncMicrosoftStoreForBusinessApps method. | def sync_microsoft_store_for_business_apps()
return MicrosoftGraph::DeviceAppManagement::SyncMicrosoftStoreForBusinessApps::SyncMicrosoftStoreForBusinessAppsRequestBuilder.new(@path_parameters, @request_adapter)
end | [
"def i_cloud_block_managed_apps_sync\n return @i_cloud_block_managed_apps_sync\n end",
"def sync\n Logger.d(\"Sync invoked for ContactsSync\")\n find_all_contacts_with_email { |emails|\n Logger.d(\"Going to sync #{emails.length} contacts\")\n # Save the contacts on the se... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.