query stringlengths 7 9.5k | document stringlengths 10 1.07M | negatives listlengths 19 19 | metadata dict |
|---|---|---|---|
Get List of Fax Receipts | def fax_receipt_list
# Prepare query url.
_query_builder = Configuration.base_uri.dup
_query_builder << '/fax/receipts'
_query_url = APIHelper.clean_url _query_builder
# Prepare and execute HttpRequest.
_request = @http_client.get(
_query_url
)
BasicAut... | [
"def fax_receipt_list\r\n\r\n # prepare query url\r\n _query_builder = Configuration.base_uri.dup\r\n _query_builder << '/fax/receipts'\r\n _query_url = APIHelper.clean_url _query_builder\r\n\r\n # prepare and execute HttpRequest\r\n _request = @http_client.get _query_url\r\n Basi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get a single fax receipt based on message id. | def get_fax_receipt(message_id)
# Validate required parameters.
validate_parameters(
'message_id' => message_id
)
# Prepare query url.
_query_builder = Configuration.base_uri.dup
_query_builder << '/fax/receipts/{message_id}'
_query_builder = APIHelper.append_ur... | [
"def get_fax_receipt(message_id)\r\n\r\n # validate required parameters\r\n validate_parameters({\r\n 'message_id' => message_id\r\n })\r\n\r\n # prepare query url\r\n _query_builder = Configuration.base_uri.dup\r\n _query_builder << '/fax/receipts/{message_id}'\r\n _query_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get a list of Fax History. | def get_fax_history(date_from = nil,
date_to = nil,
q = nil,
order = nil)
# Prepare query url.
_query_builder = Configuration.base_uri.dup
_query_builder << '/fax/history'
_query_builder = APIHelper.append_url_with_qu... | [
"def fax_history_get(opts = {})\n data, _status_code, _headers = fax_history_get_with_http_info(opts)\n data\n end",
"def fax_history_get(api_key, opts = {})\n data, _status_code, _headers = fax_history_get_with_http_info(api_key, opts)\n data\n end",
"def family_history\n get_dat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Produces a random university prefix. | def prefix
fetch('university.prefix')
end | [
"def generate_username\n digits = SecureRandom.random_number(1000000000000).to_s.ljust(12,\"0\")\n fullname = \"unlister\" + digits\n end",
"def get_random_site_name(prefix)\n site_name = prefix\n while (site_exists?(site_name))\n site_name = prefix + rand(999).to_s\n Log.logger.info(\"Tryi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Produces a random greek organization. | def greek_organization
Array.new(3) { |_| sample(greek_alphabet) }.join
end | [
"def greek_organization; end",
"def random_name\n (1..3).map {\"\" << rand(26) + 65}.to_s\n end",
"def random_string()\n\n\t\t(0...6).map { ('a'..'z').to_a[rand(26)] }.join\n\n\tend",
"def get_random_organization_type\n ORG_TYPES[rand(ORG_TYPES.size)]\nend",
"def random_string\n (0...100).map { (\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Private: Parses the payload to UTF. payload the payload string Returns a string. | def crypt_keeper_payload_parse(payload)
payload.encode('UTF-8', 'binary',
invalid: :replace, undef: :replace, replace: '')
end | [
"def decode(payload)\n return Base64.decode64(URI.unescape(payload))\n end",
"def validate_payload\n raise EmptyPayloadException.new unless payload\n raise PayloadEncodingException.new unless payload.encoding.to_s == \"UTF-8\"\n raise PayloadFormattingException.new if payload =~ / /\n end",
"def d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Private: Filters the payload. payload the payload string Returns a string. | def crypt_keeper_filter_postgres_log(payload)
payload.gsub(FILTER) do |_|
"#{$~[:operation]}([FILTERED])"
end
end | [
"def process_payload(payload)\n payload.is_a?(String) ? payload : payload.to_json\n end",
"def filter_string\n\t\treturn self.filter.to_s\n\tend",
"def preprocess_payload(payload)\n return if payload.nil?\n\n if payload.is_a?(Hash)\n headers.merge!(URL_ENCODED)\n URI.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets up this module to make API calls. The first argument is the developer's API key. The other three are the URLs corresponding to the three parts of the api. No API calls will work until this function is called. API objects will only be instantiated for URLs that are passed in. Arguments: api_key The developer's API ... | def initialize(api_key, servers, restaurant_url=nil, user_url=nil, order_url=nil)
@api_key = api_key
if servers!=:custom
unless restaurant_url.nil? and user_url.nil? and order_url.nil?
raise ArgumentError.new("Individual URL parameters can only be set if servers is set to :custom")
... | [
"def initialize(key: ENV['SHODAN_API_KEY'])\n raise \"No API key has been found or provided! ( setup your SHODAN_API_KEY environment varialbe )\" if key.nil?\n # pass the given API key to each of the underlying clients\n #\n # Note: you can optionally change these API keys later, if you\n #... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /keystrokes/1 GET /keystrokes/1.json | def show
@keystroke = Keystroke.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.json { render json: @keystroke }
end
end | [
"def new\n @keystroke = Keystroke.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @keystroke }\n end\n end",
"def destroy\n @keystroke = Keystroke.find(params[:id])\n @keystroke.destroy\n\n respond_to do |format|\n format.html { redirect_t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /keystrokes/new GET /keystrokes/new.json | def new
@keystroke = Keystroke.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @keystroke }
end
end | [
"def new\n @key = Keys.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @key }\n end\n end",
"def new\n @key = Key.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @key }\n end\n end",
"def ne... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /keystrokes POST /keystrokes.json | def create
@keystroke = Keystroke.new(params[:keystroke])
respond_to do |format|
if @keystroke.save
format.html { redirect_to @keystroke, notice: 'Keystroke was successfully created.' }
format.json { render json: @keystroke, status: :created, location: @keystroke }
else
form... | [
"def new\n @keystroke = Keystroke.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @keystroke }\n end\n end",
"def keystroke(character, *special_keys)\n special_keys = [\"command\"] if special_keys.length == 0\n special_keys_as_applescript_arra... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /keystrokes/1 PUT /keystrokes/1.json | def update
@keystroke = Keystroke.find(params[:id])
respond_to do |format|
if @keystroke.update_attributes(params[:keystroke])
format.html { redirect_to @keystroke, notice: 'Keystroke was successfully updated.' }
format.json { head :no_content }
else
format.html { render act... | [
"def update_key(key_id, request)\n start.uri('/api/key')\n .url_segment(key_id)\n .body_handler(FusionAuth::JSONBodyHandler.new(request))\n .put()\n .go()\n end",
"def update_key(key_id, request)\n start.uri('/api/key')\n .url_segment(key_id)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /keystrokes/1 DELETE /keystrokes/1.json | def destroy
@keystroke = Keystroke.find(params[:id])
@keystroke.destroy
respond_to do |format|
format.html { redirect_to keystrokes_url }
format.json { head :no_content }
end
end | [
"def destroy\n @key = Keys.find(params[:id])\n @key.destroy\n\n respond_to do |format|\n format.html { redirect_to keys_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @key = Key.find(params[:id])\n @key.destroy\n\n respond_to do |format|\n format.html { ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Recursively searches a hash for the passed key and returns the value (if there is one). | def recursive_find_by_key(key)
# Create a stack of hashes to search through for the needle which
# is initially this hash
stack = [ self ]
# So long as there are more haystacks to search...
while (to_search = stack.pop)
# ...keep searching for this particular key...
to_search.each do |k... | [
"def nested_hash_value(obj, key)\n if obj.respond_to?(:key?) && obj.key?(key)\n obj[key]\n elsif obj.respond_to?(:each)\n r = nil\n obj.find { |*a| r=nested_hash_value(a.last, key) }\n r\n end\n end",
"def nested_hash_value(obj, key)\n if obj.respond_to?(:key?) && obj.key?(key)\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Same as _deep_transform_keys_in_object, but destructively alters the original Object. | def _deep_transform_keys_in_object!(object, &block)
case object
when Hash
object.keys.each do |key|
value = object.delete(key)
object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
end
object
when Array
object.map! { |e| _deep_transform_keys_in_object!(e... | [
"def symbolize_keys_recursively!(object); end",
"def deep_symbolize_keys!\n self.replace(self.deep_symbolize_keys)\n end",
"def stringify_keys_recursively!(object); end",
"def deep_stringify_keys!\n replace(deep_stringify_keys)\n end",
"def deconstruct_keys(keys)\n if @base_object.respond... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
For the example flag its run metadata to true | def flag_example!
example.metadata[:run] = true
end | [
"def has_examples?\n meta? *EXAMPLES_KEYS\n end",
"def run_generated_counterexamples?\n @run_generated_counterexamples\n end",
"def has_example?\n false\n end",
"def example_started(example)\n end",
"def example_started(name)\n end",
"def rspec_example_metadata(cmd, stdou... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
++ Callback for when a new row from the model is created. Logs the action, the instance and the linked user, if available. | def after_create(record)
contents = to_sql_insert(record)
to_logfile(contents)
# Send a notification to the admin, if requested:
if @email_on_create
AgexMailer.action_notify_mail(
record.respond_to?(:user) ? record.user : nil,
"#{@table_name} row CREATED",
contents
).... | [
"def onNewModel(model)\n end",
"def log_creation\n log_action :create\n end",
"def log_create_event\n log_event(\"Item\",self.id,\"created\")\n end",
"def on_create\n @model_class.after_create { |r|\n r.paper_trail.record_create if r.paper_trail.save_version?\n }\n append_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
++ Appends the specified contents on logfile. | def to_logfile(contents)
File.open(@log_filename, 'a') { |f| f.puts contents } unless contents.empty?
end | [
"def append_log_file(str)\n append_file(@log_file, str)\n end",
"def add_in_logfile(date, adresse, utilisateur_id, description)\n fichier = \"app/../log/logs.txt\"\n if File.exist?(fichier)\n mode = 'a'\n check_logfile_size(fichier)\n else\n mode = 'w'\n end\n open(fichier, mode)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
TLSv1.3 reuse is always on | def test_off_tls1_3
skip 'TLSv1.3 unavailable' unless Puma::MiniSSL::HAS_TLS1_3 && CLIENT_HAS_TLS1_3
reused = run_session 'nil'
assert reused, 'TLSv1.3 session was not reused'
end | [
"def test_off_tls1_2\n ssl_vers = Puma::MiniSSL::OPENSSL_LIBRARY_VERSION\n old_ssl = ssl_vers.include?(' 1.0.') || ssl_vers.match?(/ 1\\.1\\.1[ a-e]/)\n skip 'Requires 1.1.1f or later' if old_ssl\n reused = run_session 'nil', '--tls-max 1.2'\n refute reused, 'session was reused'\n end",
"def no_tl... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
MYITASA list myItasa shows | def myitasa_shows
raise APIError, 'not logged in' if @authcode.nil?
res = call(
'myitasa/shows',
'authcode' => @authcode
)
res.body['Itasa_Rest2_Server_Myitasa']['shows']['shows'].values
end | [
"def index\n @isits = Isit.all\n end",
"def index\n @anime_lists = AnimeList.all\n end",
"def index\n @alashiab_alsoqia = AlashiabAlsoqium.all\n end",
"def index\n @akis = Aki.all\n end",
"def index\n @souhaits = Souhait.all\n end",
"def index\n @ambitos = Ambito.all\n end",
"def... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
show last myItasa subtitles | def myitasa_last_subtitles(page = nil)
raise APIError, 'not logged in' if @authcode.nil?
res = call(
'myitasa/lastsubtitles',
'authcode' => @authcode,
'page' => page
)
res.body['Itasa_Rest2_Server_Myitasa']['lastsubtitles']['subtitles'].values
end | [
"def subtitle\n content.channel.subtitle ? content.channel.subtitle.strip : ''\n end",
"def subtitle\n {}\n end",
"def subtitle\n if subtitle_override.present?\n subtitle_override\n else\n event.subtitle\n end\n end",
"def add_subtitles(file, show: false)\n \n command ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
remove a show from myItasa | def myitasa_remove_show(show_id, version)
raise APIError, 'not logged in' if @authcode.nil?
res = call(
'myitasa/removeShowFromPref',
'authcode' => @authcode,
'show_id' => show_id,
'version' => version
)
res.body['Itasa_Rest2_Server_Myitasa']['removeShowFromPref'... | [
"def delete_tvshow(db, show)\n\tdb.execute(\"DELETE FROM tvshows WHERE show = ?\", [show])\nend",
"def remove_video(show: false)\n command = \"ffmpeg -i #{@file_in} -vn #{@file_out}\"\n run command, show\n end",
"def remove widget\n \n end",
"def hide\n @visible = false\n\n store\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Initialise with a lexicon directory | def initialize(lexicon_dir = nil)
@tagparser = USASTools::SemTag::Parser.new(USASTools::SemTag::Taxonomy.new(TAXONOMY_FILE))
@lexicons = load_lexicons(lexicon_dir) if lexicon_dir
@valid_languages = Dir.glob(File.join(TEMPLATE_DIR, LANGUAGE_REF_DIR, '*.erb')).map{ |x| File.basename(x).gsub(/\... | [
"def load_lexicons(dir)\n require 'usastools/lexicon'\n\n puts \"Loading lexicons from #{dir}...\"\n pl = USASTools::Lexicon::Parser.new(\n {semtag_parser: USASTools::SemTag::Parser.new(true, lambda{|*_| return true}, lambda{|*_| return true})}, \n {}, \n {\n case_sensitive: false,\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Is the action valid at this time? | def valid?(action)
self.respond_to?(action.to_sym) && VALID_ACTIONS.include?(action)
end | [
"def valid?\n begin\n valid!\n rescue *ERRORS => ex\n logger.warn \"ActionInstance invalid: #{ex.message}\"\n return false\n end\n\n true\n end",
"def runs_validations_on_action?\n false\n end",
"def is_valid_action?(aid)\n return aid ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Check if a worker has done a word before | def check_worker_id(args)
# Load params
worker = args['worker'].to_s.strip
word = args['word'].to_s.strip.downcase
# Load hash of who has done what
worker_words = YAML::Store.new(AMT_WORKER_WORD_LIST)
previous_work = worker_words.transaction do (worker_words[worker] && worker_words[worke... | [
"def word_complete?\r\n if @word_in_progress.index(\"_\") == nil\r\n true\r\n else\r\n false\r\n end\r\n end",
"def has_worker?(worker)\n workers.include?(worker)\n end",
"def running_phrase_check(phrase)\n # Check if this phrase has been found before\n if @phrases[phrase.word_coun... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Load all lexicons from a directory and return them indexed by basename | def load_lexicons(dir)
require 'usastools/lexicon'
puts "Loading lexicons from #{dir}..."
pl = USASTools::Lexicon::Parser.new(
{semtag_parser: USASTools::SemTag::Parser.new(true, lambda{|*_| return true}, lambda{|*_| return true})},
{},
{
case_sensitive: false,
error_cb:... | [
"def load_lexers\n # The trailing slash is necessary to avoid lexers being loaded multiple\n # times by `Lexers.load_lexer`\n lexer_dir = File.join(LIB_DIR, \"rouge/lexers/\")\n Dir.glob(File.join(lexer_dir, '*.rb')).each do |f|\n Lexers.load_lexer(f.sub(lexer_dir, ''))\n end\n en... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Parse JSON from the selection form. Ensures that the json is internallyconsistent, and strips all of the data out into a new, ordered, list of tags in descending order of preference. | def parse_tag_JSON(json)
obj = JSON.parse(json)
# Each tag should have
#
# prefix: prefix,
# name: name,
# positive: positive
#
# and each input json should have
# { order: [ prefix, prefix...]
# selection: { prefix: {tag as above},
# prefix: {tag ... | [
"def parse(hash)\n hash = hash.with_indifferent_access\n options = create_options(hash[:items])\n options.current_selected_index = hash[:selected]\n options\n end",
"def parse json; return JSON.parse File.read json end",
"def parse_json\n matchers = JSON_PATTERN.match(scr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Functions for handling band_musician HABTM management GET /bands/1/addmusician | def add_musician
@band = Band.find(params[:id])
end | [
"def index\n @bands = @current_musician.bands\n end",
"def add_song_and_artist(music_library, artist, song)\n music_library[artist] = song \n return music_library\nend",
"def add_album=album\n\t\t@albums << album\n\tend",
"def store_hash(item, index)\n #there can be multiple artist seperated by '+' so ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the devise scope to be used in the controller. If you have custom routes, you are required to call this method (also aliased as :as) in order to specify to which controller it is targeted. as :user do get "sign_in", to: "devise/sessionsnew" end Notice you cannot have two scopes mapping to the same URL. And remembe... | def devise_scope(scope)
constraint = lambda do |request|
request.env["devise.mapping"] = Devise.mappings[scope]
true
end
constraints(constraint) do
yield
end
end | [
"def devise_scope(scope); end",
"def detect_devise_scope(*args)\n unless scope = args.detect { |arg| arg.is_a?(Symbol) && !DEVISE_ACTIONS.keys.include?(arg) } || Warden::Manager.default_scope\n raise \"No scope could be detected. Ensure that you got a authenticatable Devise model in you app.\"\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Set resonable defaults for a new schedule disposition update event | def set_defaults
super
self.disposition_year ||= current_planning_year_year
end | [
"def set_defaults\n super\n self.asset_event_type ||= AssetEventType.find_by_class_name(self.name)\n prev_ops_update = self.previous_event_of_type\n if prev_ops_update\n self.annual_affected_ridership ||= prev_ops_update.annual_affected_ridership\n self.annual_dollars_generated ||= prev_op... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /faqs/1 DELETE /faqs/1.json | def destroy
@faq = Helpdesk::Faq.find(params[:id])
@faq.destroy
respond_to do |format|
format.html { redirect_to admin_faqs_url }
format.json { head :no_content }
end
end | [
"def destroy\n @faq = Faq.find(params[:id])\n @faq.destroy\n\n respond_to do |format|\n format.html { redirect_to faqs_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @faq = Faq.find(params[:id])\n @faq.destroy\n\n respond_to do |format|\n format.html { redirect_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /lookup_pettracers/1 GET /lookup_pettracers/1.xml | def show
@lookup_pettracer = LookupPettracer.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @lookup_pettracer }
end
end | [
"def new\n @lookup_pettracer = LookupPettracer.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @lookup_pettracer }\n end\n end",
"def show\n @lookup_recruitsource = LookupRecruitsource.find(params[:id])\n\n respond_to do |format|\n format.h... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /lookup_pettracers/new GET /lookup_pettracers/new.xml | def new
@lookup_pettracer = LookupPettracer.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @lookup_pettracer }
end
end | [
"def create\n @lookup_pettracer = LookupPettracer.new(params[:lookup_pettracer])\n\n respond_to do |format|\n if @lookup_pettracer.save\n format.html { redirect_to(@lookup_pettracer, :notice => 'Lookup pettracer was successfully created.') }\n format.xml { render :xml => @lookup_pettracer,... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /lookup_pettracers POST /lookup_pettracers.xml | def create
@lookup_pettracer = LookupPettracer.new(params[:lookup_pettracer])
respond_to do |format|
if @lookup_pettracer.save
format.html { redirect_to(@lookup_pettracer, :notice => 'Lookup pettracer was successfully created.') }
format.xml { render :xml => @lookup_pettracer, :status =>... | [
"def create\n @lookup_pettracer = LookupPettracer.new(lookup_pettracer_params)#params[:lookup_pettracer])\n\n respond_to do |format|\n if @lookup_pettracer.save\n format.html { redirect_to(@lookup_pettracer, :notice => 'Lookup pettracer was successfully created.') }\n format.xml { render :... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /lookup_pettracers/1 PUT /lookup_pettracers/1.xml | def update
@lookup_pettracer = LookupPettracer.find(params[:id])
respond_to do |format|
if @lookup_pettracer.update_attributes(params[:lookup_pettracer])
format.html { redirect_to(@lookup_pettracer, :notice => 'Lookup pettracer was successfully updated.') }
format.xml { head :ok }
... | [
"def update\n @lookup_pettracer = LookupPettracer.find(params[:id])\n\n respond_to do |format|\n if @lookup_pettracer.update(lookup_pettracer_params)#params[:lookup_pettracer], :without_protection => true)\n format.html { redirect_to(@lookup_pettracer, :notice => 'Lookup pettracer was successfully... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /lookup_pettracers/1 DELETE /lookup_pettracers/1.xml | def destroy
@lookup_pettracer = LookupPettracer.find(params[:id])
@lookup_pettracer.destroy
respond_to do |format|
format.html { redirect_to(lookup_pettracers_url) }
format.xml { head :ok }
end
end | [
"def destroy\n @lookup_recruitsource = LookupRecruitsource.find(params[:id])\n @lookup_recruitsource.destroy\n\n respond_to do |format|\n format.html { redirect_to(lookup_recruitsources_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @lookup = Lookup.find(params[:id])\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /vehicle_fines GET /vehicle_fines.json | def index
@vehicle_fines = VehicleFine.all
end | [
"def index\n @fines = Fine.all\n end",
"def show\n @vehicle_fuel = VehicleFuel.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @vehicle_fuel }\n end\n end",
"def vehicle\n fetch('conan.vehicles')\n end",
"def index... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /vehicle_fines POST /vehicle_fines.json | def create
@vehicle_fine = VehicleFine.new(vehicle_fine_params)
respond_to do |format|
if @vehicle_fine.save
format.html { redirect_to @vehicle_fine, notice: 'Vehicle fine was successfully created.' }
format.json { render :show, status: :created, location: @vehicle_fine }
else
... | [
"def create\n @vehicle_fine = VehicleFine.new(vehicle_fine_params)\n\n respond_to do |format|\n if @vehicle_fine.save\n format.html { redirect_to @vehicle_fine, notice: (t 'vehicle_fines.title2')+(t 'actions.created') }\n format.json { render action: 'show', status: :created, location: @veh... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /vehicle_fines/1 PATCH/PUT /vehicle_fines/1.json | def update
respond_to do |format|
if @vehicle_fine.update(vehicle_fine_params)
format.html { redirect_to @vehicle_fine, notice: 'Vehicle fine was successfully updated.' }
format.json { render :show, status: :ok, location: @vehicle_fine }
else
format.html { render :edit }
... | [
"def update\n respond_to do |format|\n if @vehicle_fine.update(vehicle_fine_params)\n format.html { redirect_to @vehicle_fine, notice: (t 'vehicle_fines.title2')+(t 'actions.updated') }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n forma... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /vehicle_fines/1 DELETE /vehicle_fines/1.json | def destroy
@vehicle_fine.destroy
respond_to do |format|
format.html { redirect_to vehicle_fines_url, notice: 'Vehicle fine was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n @vehicle_fine.destroy\n respond_to do |format|\n format.html { redirect_to vehicle_fines_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @vehicle_fuel = VehicleFuel.find(params[:id])\n @vehicle_fuel.destroy\n\n respond_to do |format|\n format.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
constructs a uri for a capture screen with the necesary params and embeds it in an iframe in the page. | def embed_screen(params = {})
@iframe_src = screen_uri(params)
render "iframe"
end | [
"def screen_uri(params = {}, sn = screen_name)\n uri = URI(\"https://\" + app.captureui_addr)\n uri.path = \"/oauth/#{sn}\"\n uri.query = URI.encode_www_form(params)\n uri.to_s\n end",
"def capture_screen\n create_screenshot\n end",
"def screencapture(options:)\n get_device do |device|... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
constructs the uri of a capture_screen from params | def screen_uri(params = {}, sn = screen_name)
uri = URI("https://" + app.captureui_addr)
uri.path = "/oauth/#{sn}"
uri.query = URI.encode_www_form(params)
uri.to_s
end | [
"def print_screen_capture_url(scenario)\n screen_captures = Warden::Warden_Session.get_scenario_screen_capture()\n\n if screen_captures[scenario]\n screen_captures[scenario].each do |screen_capture|\n @io.puts format_string( \" \" + screen_capture, :failed)\n end\n end\n end",
"def bui... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
dispatcher is the action that get called for /:app_name/:screen_name routes. Turns screen into an action, and calls it. If it can't find an action it will remove suffixes until it can, or until it decides to call a generic handler. note that all actions will go through here, so rails will default to rendering /demo/dis... | def dispatcher
screen = screen_name
# continuosly remove tokens seperated by '_', starting from the end
# until there are no more tokens, or we find one that we respond to
begin
if self.respond_to?(screen.to_sym)
self.method(screen).call
return
end
tokens = screen.spli... | [
"def dispatch_to(dispatcher)\n @jr_method_args.each { |args|\n # copy args so original is preserved\n handler_method, jr_methods =\n extract_handler_method(Array.new(args))\n jr_methods.map! { |m| m.to_s }\n\n handler = has_handler_for?(handler_method) ?\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create n sample posts | def create_samples(n)
n.times do |i|
Post.create(title: "New Post #{i}", body: "Body of post #{i}", created_at: Time.now)
end
end | [
"def make_user_posts\n\tusers = User.all(limit: 10)\n\t15.times do |n|\n\t\tcontent = Faker::Lorem.sentence(5)\n\t\tusers.each { |u| u.posts.create!(content: content) }\n\tend\nend",
"def create_posts(user_ids, topics, num)\n r = []\n user_ids.each do |u_id|\n (1..num).each do\n r << FactoryGirl... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /drawables GET /drawables.json | def index
@drawables = Drawable.all
respond_to do |format|
format.html # index.html.erb
format.json { render json: @drawables }
end
end | [
"def index\n @drawings = Drawing.all\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @drawings }\n end\n end",
"def show\n @drawable = Drawable.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n f... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /drawables/1 GET /drawables/1.json | def show
@drawable = Drawable.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.json { render json: @drawable }
end
end | [
"def index\n @drawables = Drawable.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @drawables }\n end\n end",
"def show\n @drawing = Drawing.find(params[:id])\n\n render json: @drawing\n end",
"def destroy\n @drawable = Drawable.find(param... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /drawables/new GET /drawables/new.json | def new
@drawable = Drawable.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @drawable }
end
end | [
"def new\n @draw = Draw.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @draw }\n end\n end",
"def new\n @draw = Draw.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @draw }\n end\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /drawables POST /drawables.json | def create
@drawable = Drawable.new(params[:drawable])
respond_to do |format|
if @drawable.save
format.html { redirect_to @drawable, notice: 'Drawable was successfully created.' }
format.json { render json: @drawable, status: :created, location: @drawable }
else
format.html ... | [
"def index\n @drawables = Drawable.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @drawables }\n end\n end",
"def create\n @drawing = Drawing.new(params[:drawing])\n\n if @drawing.save\n render json: @drawing, status: :created, location: @... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /drawables/1 PUT /drawables/1.json | def update
@drawable = Drawable.find(params[:id])
respond_to do |format|
if @drawable.update_attributes(params[:drawable])
format.html { redirect_to @drawable, notice: 'Drawable was successfully updated.' }
format.json { head :no_content }
else
format.html { render action: "... | [
"def index\n @drawables = Drawable.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @drawables }\n end\n end",
"def update\n @drawing = Drawing.find(params[:id])\n\n if @drawing.update_attributes(params[:drawing])\n head :no_content\n els... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /drawables/1 DELETE /drawables/1.json | def destroy
@drawable = Drawable.find(params[:id])
@drawable.destroy
respond_to do |format|
format.html { redirect_to drawables_url }
format.json { head :no_content }
end
end | [
"def destroy\n @draw = Draw.find(params[:id])\n @draw.destroy\n\n respond_to do |format|\n format.html { redirect_to draws_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @drawing = Drawing.find(params[:id])\n @drawing.destroy\n\n respond_to do |format|\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the conjugate of _obj_ q which is the quaternion q = a b_i_ c_j_ d_k_. | def conjugate
Quaternion.new(@a, -1 * @b, -1 * @c, -1 * @d)
end | [
"def conjugate\r\n quaternion.conjugate!\r\n end",
"def conjugate\n return Quaternion.new(@beta0, *(-1*@beta_s))\n end",
"def conjugate\n Complex(@real, -@imag)\n end",
"def conjugate\n Complex(@real, -@image)\n end",
"def -(q)\n beta0, beta_s = q.get()\n return Quaternion.new(@bet... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the norm of this Quaternion. | def norm
Math.sqrt((@a**2) + (@b**2) + (@c**2) + (@d**2))
end | [
"def norm\r\n\t\tMath.sqrt(norm2)\r\n\tend",
"def normalize\n f = 1.0 / length\n Normal3.new(@x * f, @y * f, @z * f)\n end",
"def norm\n return nil unless @points.size == @dimension\n q = 0\n @points.combination(2) do |p|\n q += ((p[0][1] - p[1][1]) ** 2.0)\n end\n r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the versor of this Quaternion | def versor
self / norm
end | [
"def inspect\n return \"Quaternion(#{@w}; #{@v})\"\n end",
"def getQuaternion()\n return @q\n end",
"def voltage\n if voltages.size > 0\n if voltages.size > 1\n voltages\n else\n voltages.first\n end\n end\n end",
"def - other\n w ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Add a new node to the start of the list | def prepend( value )
new_node = Node.new value
# Whatever node was at the start of the list, it
# is now the 'next' node for our newly created node
new_node.next = @head
# The new head of the list is set to be the new
# node that we just created
@head = new_node
end | [
"def prepend( value )\n new_node = Node.new value\n\n # Whatever was at the start of the list, is now the 'next'\n # node for the new node we just created\n new_node.next = @head\n\n # The new head of the list is set to be the new node\n # that we just created\n @head = new_node\n end",
"def... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Helper to set date values. Converts dates, in Date or String format, to a RDF::Literal. | def date_setter(name, d)
case d.class.name
when 'RDF::Literal::Date', 'NilClass'
value = d
when 'String'
begin
if d.empty?
value = nil
else
value = ::RDF::Literal.new(Date.parse(d))
end
rescue
raise ArgumentError, ... | [
"def result\n map_value(converted_value: RDF::Literal.new(\n value.value,\n datatype: PermissiveSchema.valkyrie_datetime\n ))\n end",
"def set_date(date)\n param = date[:year]\n if date.key? :month\n param << \":\" << date[:month]\n param << \":\" << ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
log runtime via dumping or curling it into the runtime log location | def record_test_runtime(mode, results, log)
data = results.map { |test, time| "#{test}:#{time.round(2)}" }.join("\n") << "\n"
case mode
when 'simple'
File.write(log, data)
when 'amend'
if id = ENV["BUILDKITE_JOB_ID"]
slug = ENV.fetch("BUILDKITE_ORG_SLUG") + "-" + ENV.f... | [
"def log_startup\n log_environment\n log_dispatcher\n log_app_name\n end",
"def log_startup\n log_environment\n log_dispatcher\n log_app_name\n end",
"def log_version_and_pid\n ::NewRelic::Agent.logger.debug \"New Relic Ruby ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
This forces Rails to load all fixtures, then prevents it from "deleting and reinserting all fixtures" when a new connection is used (forked). | def preload_fixtures
return if @options.fetch(:no_fixtures)
fixtures = (ActiveSupport::VERSION::MAJOR == 3 ? ActiveRecord::Fixtures : ActiveRecord::FixtureSet)
# reuse our pre-loaded fixtures even if we have a different connection
fixtures_eigenclass = class << fixtures; self; end
fixtur... | [
"def load_fixtures\n if ActiveRecord::Base.connection.open_transactions != 0\n ActiveRecord::Base.connection.decrement_open_transactions\n ActiveRecord::Base.connection.rollback_db_transaction\n end\n ActiveRecord::Base.clear_active_connections!\n\n # In Rails 3.0.x, load_fixtures sets the @lo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /voxels POST /voxels.json | def create
@method = 'create'
@voxel = Voxel.new(voxel_params)
respond_to do |format|
if @voxel.save
flash[:notice] = '作成されました！'
format.html { redirect_to action: 'index' }
format.json { render action: 'show', status: :created, location: @voxel }
else
format.html... | [
"def create\n @vox = Vox.new(params[:vox])\n\n respond_to do |format|\n if @vox.save\n format.html { redirect_to @vox, notice: 'Vox was successfully created.' }\n format.json { render json: @vox, status: :created, location: @vox }\n else\n format.html { render action: \"new\" }\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /voxels/1 DELETE /voxels/1.json | def destroy
@voxel.destroy
respond_to do |format|
format.html { redirect_to voxels_url }
format.json { head :no_content }
end
end | [
"def destroy\n @vox = Vox.find(params[:id])\n @vox.destroy\n\n respond_to do |format|\n format.html { redirect_to voxes_url }\n format.json { head :no_content }\n end\n end",
"def delete_aos_version(args = {}) \n delete(\"/aosversions.json/#{args[:aosVersionId]}\", args)\nend",
"def destr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Populate the Hit objects with their instances. This is invoked the first time any hit has its instance requested, and all hits are loaded as a batch. | def populate_hits(session)
id_hit_hash = Hash.new { |h, k| h[k] = {} }
hits.each do |hit|
id_hit_hash[hit.class_name][hit.primary_key] = hit
end
id_hit_hash.each_pair do |class_name, hits|
hits_for_class = id_hit_hash[class_name]
hits.each do |... | [
"def populate_hits #:nodoc:\n id_hit_hash = Hash.new { |h, k| h[k] = {} }\n hits.each do |hit|\n id_hit_hash[hit.class_name][hit.primary_key] = hit\n end\n id_hit_hash.each_pair do |class_name, hits|\n ids = hits.map { |id, hit| hit.primary_key }\n data_accesso... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
run through using each method def reverse_each_word(string) string_to_array = string.split reverse_array = [] string_to_array.each do |word| reverse_array << word.reverse end each reverse_array.join(' ') end run through exchanging .each for .collect | def reverse_each_word(string)
string_to_array = string.split
reverse_array = []
string_to_array.collect do |word|
reverse_array << word.reverse
end #each
reverse_array.join(' ')
end | [
"def reverse_each_word(string)\n separate_words = string.split\n \n reversed_words = separate_words.collect {|word| word.reverse}\n \n p reversed_words.join(\" \")\nend",
"def reverse_each_word(string)\r\n word_list = string.split(\" \")\r\n word_list.collect do |word|\r\n word.reverse!\r\n end\r\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Format file with magic numbers. | def format_file(file)
out = ''
file.magic_numbers.each do |num|
if @color
val = red(num.value)
line = yellow(num.line)
path = pink(file.path)
else
val = num.value
line = num.line
path = file.path
end... | [
"def transform(file, format:); end",
"def filemagic\n @filemagic ||= FileMagic.new(FileMagic::MAGIC_MIME_TYPE)\n end",
"def filemagic\n @filemagic ||= FileMagic.new(FileMagic::MAGIC_MIME_TYPE)\n end",
"def set_magic(file, bytes)\n raise unless bytes.size == 4\n unless nowrite()\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /route_lines/1 GET /route_lines/1.xml | def show
@route_line = RouteLine.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @route_line }
end
end | [
"def new\n @route_line = RouteLine.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @route_line }\n end\n end",
"def show\n @line = Line.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /route_lines/new GET /route_lines/new.xml | def new
@route_line = RouteLine.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @route_line }
end
end | [
"def new\n @line = Line.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @line }\n end\n end",
"def new\n @old_route = OldRoute.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @old_route }\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /route_lines POST /route_lines.xml | def create
@route_line = RouteLine.new(params[:route_line])
respond_to do |format|
if @route_line.save
format.html { redirect_to(@route_line, :notice => t('record_created')) }
format.xml { render :xml => @route_line, :status => :created, :location => @route_line }
else
for... | [
"def post_route(route, message)\n raise TypeError unless route.is_a? Route\n @changeset = @api.create_changeset(message, tags={'created_by'=>'ITCR'})\n ways_list = []\n nodes_list = create_node_list(route.path)\n\n until nodes_list.empty? # For node's maximum limit of a way\n way_nodes = nodes_l... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /route_lines/1 PUT /route_lines/1.xml | def update
@route_line = RouteLine.find(params[:id])
respond_to do |format|
if @route_line.update_attributes(params[:route_line])
format.html { redirect_to(@route_line, :notice => t('record_updated')) }
format.xml { head :ok }
else
format.html { render :action => "edit" }
... | [
"def update\n @line = Line.find(params[:id])\n\n respond_to do |format|\n if @line.update_attributes(params[:line])\n flash[:notice] = 'Line was successfully updated.'\n format.html { redirect_to(lines_path) }\n format.xml { head :ok }\n else\n format.html { render :acti... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /route_lines/1 DELETE /route_lines/1.xml | def destroy
@route_line = RouteLine.find(params[:id])
@route_line.destroy
respond_to do |format|
format.html { redirect_to(route_lines_url) }
format.xml { head :ok }
end
end | [
"def destroy\n @route = Line.find_by_slug(params[:line_id]).routes.find(params[:id])\n @route.destroy\n\n respond_to do |format|\n format.html { redirect_to routes_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @line = Line.find(params[:id])\n @line.destroy\n\n respo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Compose libcurl header string from key and value. Also replaces null bytes, because libcurl will complain otherwise. | def compose_header(key, value)
Util.escape_zero_byte("#{key}: #{value}")
end | [
"def parse_headers(headers_hash)\n header_string = \"\"\n for header in headers_hash.select { |k,v| k.match(\"^HTTP.*\") } do\n header_string += header[0]+\":\"+header[1]+\"|\"\n end\n return header_string\n end",
"def format_user_agent_header(key, values)\n header = \"#{key} #{va... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
def has_player_1_won?(player_1.weapon_choice,player_2.weapon_choice) RULES[:rock][:paper] end | def draw?
player_1.weapon_choice == player_2.weapon_choice
end | [
"def player_1_wins_with_rock\n @player_1_weapon == \"rock\" && @player_2_weapon != \"paper\"\n end",
"def player_1_wins_with_paper\n @player_1_weapon == \"paper\" && @player_2_weapon != \"scissors\"\n end",
"def player_1_wins_with_scissors\n @player_1_weapon == \"scissors\" && @player_2_weapon != \"r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get the contents of a a directory as relative pathnames (without the root dir prepended) | def relative_dir_files(directory)
files = Dir["#{file_root(directory)}/**/*"]
files.map! { |file| file.gsub(/#{file_root}/, '') }
end | [
"def relative_directory\n return '' unless @directory_root\n @path - @directory_root - name\n end",
"def GetDirectoryPathsFromRelativeBase(path)\n pathParts = path.RelativePathParts\n paths = []\n for i in 1..pathParts.length\n\tsubPath = ProjectPath.new(JoinPaths(pathParts.slice(0, i)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generate the repository dists | def generate_dists(pkg_hash)
pkg_hash.each do |origin_name, dists|
dists.each do |dist_name, dist_args|
dist_args[:components].each do |component_name, arches|
packages = arches.values.flatten.compact.map(&:values).flatten.compact.map(&:values).flatten.compact
p... | [
"def generate_dists(pkg_hash)\n pkg_hash.each do |origin_name, dists|\n dists.each do |dist_name, dist_args|\n dist_args[:components].each do |component_name, arches|\n arches.each do |arch_name, packages|\n package_file(origin_name, dist_name, component_name, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sign file if configured for signing | def sign_file_if_setup(opts = nil)
path = yield
if signer && options[:sign]
signer.file(path, nil, opts)
end
path
end | [
"def sign_file_if_setup\n path = yield\n if signer && options[:sign]\n signer.file(path)\n end\n path\n end",
"def sign_file_with_gpg path\n return unless sign?\n CodeSigning::sign_file_with_gpg(path,\n :password => @signing_key_pa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Attempt to bind to active directory, time out after N seconds, return true or false | def bind
return false unless !@connection.nil?
begin
Timeout::timeout(10) do
return (@connection.bind) ? true : false
end
rescue
return false
end
end | [
"def mock_slow_ldap_bind!(username, password, delay_milliseconds)\n slow_mock_ldap = MockLdap.new({\n auth: {\n username: username,\n password: password\n }\n })\n allow(slow_mock_ldap).to receive(:bind) do\n sleep(delay_milliseconds/1000.0)\n false\n end\n allow(Moc... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Build user distinguished name for active directory account | def ldap_distinguished_name(user)
distinguished_name = "cn=#{user.human_name},"
if user.is_staff
if !user.masters_program.blank? && organization_units.include?(user.masters_program)
distinguished_name += "ou=" + user.masters_program + ",ou=Staff,"
else
distinguished_name += "ou=Staf... | [
"def ldap_distinguished_name(user)\n distinguished_name = \"cn=#{user.human_name},\"\n base_distinguished_name = \"dc=cmusv,dc=sv,dc=cmu,dc=local\"\n\n if user.is_staff\n distinguished_name += \"ou=Staff,ou=Sync,\"\n elsif !user.masters_program.blank?\n distinguished_name += \"ou=\" + user.mas... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create base distinguished name from the active directory domain name | def base_distinguished_name
base_name = ""
AD_DOMAIN.split('.').each do |item|
base_name+="dc=#{item},"
end
base_name.chop
end | [
"def domain_name(domain)\n\tdomain.split(\".\").collect do |label|\n\t\ttrimmed_label = label.byteslice(0, 63)\n\t\ttrimmed_label.bytesize.chr + trimmed_label\n\tend.join(\"\") + \"\\x00\"\nend",
"def dn_for username\n \"uid=#{username},#{@dn_suffix}\"\n end",
"def domain\n dn.scan(/dc=(\\w+)/i).flatte... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Convert password to unicode format | def password_encode(password)
result = ""
password = "\"" + password + "\""
password.length.times { |i| result+= "#{password[i..i]}\000" }
return result
end | [
"def normalized_password\n URI.encode(CGI.unescape(password), ENCODE_PASSWORD).force_encoding(Encoding::UTF_8) if password\n end",
"def convert_password\n converted_password = Base64.encode64(self.password)\n self.password = converted_password\n end",
"def to_s\n password\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Format email with a active directory domain | def format_email_to_ad_domain(email)
return "#{email.split('@')[0]}@#{AD_DOMAIN}"
end | [
"def return_email_domain \n return \"@\" + self.email.split('@')[1]\n end",
"def formatted_email\n \"#{name} <#{email}>\"\n end",
"def render_contact_email_address(address)\n mail_to address, sanitize(address).gsub(/([@.])/, '\\1<wbr />').html_safe\n end",
"def get_domain_name_from_email_a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return names of organization units | def organization_units
if bind
units = []
AdOrganizationUnit.find_each do |local_entry|
name = local_entry.distinguishedname.split(',')[0]
units.push(name[3..name.length])
end
return units
else
return false
end
end | [
"def list_organizational_units\n treebase = GLOBAL_CONFIG[:treebase]\n\n result = []\n\n filter = Net::LDAP::Filter.construct('(objectCategory=organizationalUnit)')\n Binder.search(base: treebase, filter: filter) do |entry|\n result.push(entry.dn) if entry.dn.match?(/OU=Keycloak Groups/)\n end\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Update organization units cache table if records are more than one day old | def update_organization_units
oldest_update = AdOrganizationUnit.order('created_at').last
if bind && (oldest_update.nil? || oldest_update.created_at<1.day.ago)
filter = Net::LDAP::Filter.eq("objectClass", "organizationalunit")
results = @connection.search(:base =>"ou=Sync,"+base_distinguished_name... | [
"def ensure_cache_up_to_date\n self.last_update_timestamp = self.redis.get(\"bluster:last_update_timestamp\").to_i\n if self.last_update_timestamp.nil?\n update_object_cache\n elsif self.last_update_timestamp != File.new(self.objects_path).mtime.to_i\n update_object_cache\n end\n end",
"def... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Public: Initialize a new instance of DatedBranchCreator branch_type Name of the type of branch (e.g., staging or deployable) pull_request_id The pull request id to use for the merge options hash of options post_comment whether or not to post a comment on the pullrequest | def initialize(branch_type, pull_request_id, options={})
self.branch_type = branch_type
self.pull_request_id = pull_request_id
self.options = options
end | [
"def create_pull_request\n self.pull_request = GitHub::PullRequest.create config.github_repo, pull_request_attributes\n end",
"def create_pull_request(token, branch, repo, body, assignee)\n payload = {:title => branch, :base => base_branch, :head => branch, :body => body}.to_json\n say \... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Public: Merge the pull request's branch into the checkedout branch | def merge_pull_request
git.merge pull_request.branch
end | [
"def git_branch_merge\n initial_branch = get_current_branch\n\n branches.each do |branch|\n `git checkout #{branch}`\n `echo \"Merging master into #{branch}\" >&2`\n `git pull --rebase origin master`\n `echo \"Master merged into #{branch}\" >&2`\n end\n\n `git checkout #{initial_branch}`\nend",
"d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Public: Comment that the pull request was merged into the branch | def comment_about_merge
pull_request.write_comment comment_body
end | [
"def merge_pull_request\n git.merge pull_request.branch\n end",
"def short_message\n \"Issue pull request for branch #{story_branch}\"\n end",
"def pull_request_comment(repo, comment_id, options = T.unsafe(nil)); end",
"def hendl_pr(original)\n puts \"#{original.number} is a pull request\"\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Public: The content of the comment to post when merged Returns a String | def comment_body
body = "Merged into #{branch_to_merge_into}."
if options[:user_notifications]
body << " /cc #{options[:user_notifications].map {|name| "@#{name}"}.join(' ')}"
end
body
end | [
"def comments_text\n return self.comments.inject(\"\") do |string, comment| \n string + \n (string.empty? ? \"\" : \"\\n\") +\n comment.email +\n \": \" +\n comment.message\n end\n end",
"def comments_text\n return self.comments.inject(\"\") do |string, comment|\n s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Public: Find the pull request Returns a GitHub::PullRequest | def pull_request
@pull_request ||= GitHub::PullRequest.new config.github_repo, pull_request_id
end | [
"def pull_request\n @pull_request ||= client.pull_request(repo, number)\n end",
"def pull_request\n github_payload['pull_request']\n end",
"def pull_request(repository_full_name, pr_number)\n # Ensure that the pull request exists.\n client = Octokit::Client.new(access_token: Planter.co... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Check with the rubygems api to see if this gem name is available. | def gem_is_available?
@thor.say("Check if #{@name} is available as a gem name.", :yellow)
uri = URI.parse("https://rubygems.org/api/v1/gems/#{@name}.json")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri.request_uri)
response = http.request(request... | [
"def gem_name_taken?(name)\n require 'json'\n url = \"https://rubygems.org/api/v1/gems/#{name}.json\"\n response = JSON.parse(FastlaneCore::Helper.open_uri(url).read)\n return !!response['version']\n rescue\n false\n end",
"def gem_available?(name)\n gem name\n true\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
convert the current line to a rect | def rect()
Rect.new(p1, p2)
.stroke(stroke)
.fill(fill)
.fill_phase(fill_phase)
.line_width(line_width)
.line_dash(line_dash)
end | [
"def item_rect(index)\n rect = super(index)\n rect.y += line_height\n rect\n end",
"def item_rect(index)\r\n rect = Rect.new\r\n rect.x = index % 10 * 32 + index % 10 / 5 * 16\r\n rect.y = index / 10 * line_height\r\n rect.width = 32\r\n rect.height = line_height\r\n rect\r\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
validate that the given publisher alpha id exists used in conjunction with plugin settings page, where client ID is set | def checkPublisherID
begin
publisher = Publisher.find_by(alpha_id: params[:publisher_alpha_id], verified: true) # grab publisher from clientID
logger.info "publisher url: #{params['publisher_url']}"
publisher_url = params['publisher_url']
publisher_domain = URI(publisher_url).host
@val... | [
"def has_client_id?\n client_id && (client_id != '*')\n end",
"def get_publisher_id\n #if pub = get_publisher\n # return pub.id\n #end\n nil\n end",
"def publisher_id\n 340\n end",
"def valid_id?(distribution_id)\n VbmsDistribution.exists?(id: distribution_id)\n end",
"def chec... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
creates a new mentorship relationship paramters from JSON: name, pdSupervisor, pdInstitution, pdStartYear, pdEndYear currently assumes that all parameters are not nil not sure if we should render as json | def create
Rails.logger.info(params)
if params.has_key?(:name) && params.has_key?(:pdSupervisor) && params.has_key?(:pdInstitution) && params.has_key?(:pdStartYear) && params.has_key(:pdEndYear)
# need to find the person, supervisor, and institution IDs first
name_id = Person.find_person_id(params[:... | [
"def create\n Rails.logger.info(params)\n if params.has_key?(:year) && params.has_key(:type) && params.has_key(:institution) && params.has_key(:supervisor) && params.has_key(:name)\n # need to find the degree, person, and supervisor IDs first\n degree_id = Degree.find_degree_id(params[:year], params... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a new provider to the provider collection. | def add extension, provider
providers[extension] = provider
end | [
"def add_provider(pname)\n if providers.any? { |p| p.name == pname }\n raise Error::BoxError::VersionProviderExistsError,\n \"Provider #{pname} already exists for box #{box.tag} version #{version}\"\n end\n pv = Provider.new(version: self, name: pname)\n clean(data: {... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
List of configured providers. | def providers
@providers ||= {}
end | [
"def providers\n @providers ||= []\n end",
"def providers\n @providers.keys\n end",
"def registered_providers\n providers_registry.providers.keys\n end",
"def providers\n @providers ||= {}\n end",
"def providers\n driver(current_driver).providers\n end",
"de... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Resets the provider collection to the initial values. | def reset
providers.clear
configured_providers.each { |k, v| self[k] = v }
self.default = configured_default
end | [
"def reset!\n @collection = []\n end",
"def reset_initial_values\n @initial_values.clear if @initial_values\n @missing_initial_values.clear if @missing_initial_values\n end",
"def reset!\n @registered_items = self.initial_state.dup\n end",
"def reset\n identity_map.clear\n p... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get provider corresponding to a given format. | def [] format
providers[format]
end | [
"def get_provider(provider)\n configuration.providers.find { |rp| rp.namespace.casecmp(provider) == 0 }\n end",
"def get_provider(name)\n provider = nil\n @providers.each do |p|\n provider = p if p[:id].eql?(name.to_sym)\n end\n provider\n end",
"def find(format_name)\n numeri... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
If any of the 'indicator properties' in the attribute hash are not nil, the boolean property is set to true in the attribute hash. Otherwise it's set to the default (or not set if default=nil). Returns the attribute hash. | def infer_boolean bool_property, indicator_properties, atts, default=nil
atts[bool_property] = default unless (atts[bool_property] or default.nil?)
indicator_properties.each do |x|
atts[bool_property] = true unless atts[x].nil?
end
return atts
end | [
"def merge_boolean_attributes!(attributes)\n attributes.each do |key, value|\n if value.is_a?(TrueClass) or value.is_a?(FalseClass)\n attributes[key] = (attributes[key] == true) ? \"Yes\" : \"No\"\n end\n end\n end",
"def boolean_attributes\n @boolean_attributes\n end",
"def bool... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Cleans a list of Boolean values to be either true or false | def clean_bool dirty_vals
vals = []
array = separate(dirty_vals)
array.each { |dirty_val|
val = get_b(dirty_val)
#if val.nil? and (!dirty_val.nil? and dirty_val.strip!='')
# val = dirty_val.match(/(not applicable|n\/a|not available)/i).nil?
#end
vals << val
}
if vals.... | [
"def remove_falsy_values list\n list.select { |ele| !!ele }\n end",
"def remove_nils_and_false_from_array(array)\n\tarray.reject! { |item| item == nil || item == false }\nend",
"def remove_falsy_values(list)\n list.select {|element| !!element}\nend",
"def remove_nils_and_false_from_array(arr)\n arr.comp... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
see if any sibling response exists with the same respondent_id | def respondent_already_answered?
sibling_responses.exists?(user_id: user_id)
end | [
"def respondent_already_answered?\n sibling_responses.exists?(responder_id: self.responder_id)\n end",
"def respondent_already_answered?\n sibling_responses.exists?(respondent_id: self.respondent.id)\n end",
"def respondent_already_answered?\n sibling_responses.where('user_id = ?', self.user_id).... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
User Can't Create Multiple Responses To The Same Question | def not_duplicate_response
if respondent_already_answered?
errors[:user_id] << 'this user has already answered this question'
end
# unless sibling_responses.where(user_id: user_id).empty?
end | [
"def not_duplicate_response\n if respondent_already_answered?\n errors[:respondent] << 'Cannot create multiple responses to the same Question'\n end\n end",
"def one_response_per_question_per_user\n if self.question.responses.include?(Response.where(user_id: self.user_id))\n errors.add(:user_i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Author Can't Respond To Own Poll The simplest way is to use associations to traverse from a Response object back to the AnswerChoice, to the Question, and finally the Poll. You can then verify whether the poll's author is the same as the respondent_id. This may involve multiple queries, but we will later improve this. ... | def respondent_is_not_author_poll?
#
# respondend.id == author.id
if question.poll.author.id == user.id
errors[:user_id] << 'author should not answer to his/her poll'
end
end | [
"def author_cant_respond\r\n author_id = self.respondent.id\r\n question_author_id = question.poll.author.id\r\n return author_id == question_author_id\r\n end",
"def not_author_response\n if author_respondent?\n errors[:author] << 'cannot answer their own poll'\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Getter for the +synonym_dictionaries+ class variable | def synonym_dictionaries
@@synonym_dictionaries
end | [
"def synonym_dict\n return @@synonym_dict if @@synonym_dict\n @@synonym_dict = {}\n config[\"synonyms\"].each do |syn_set|\n syn_set.each {|syn| @@synonym_dict[syn] ||= Set.new; @@synonym_dict[syn].merge syn_set }\n end\n @@synonym_dict\n end",
"def synonyms\n get_term_metadata\n @s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks if the given +dictionary+ symbol is a key in the +synonym_dictionaries+ class variable | def dictionary_exists? dictionary
synonym_dictionaries.key?(dictionary.capitalize)
end | [
"def check_for_dictionary(dictionary)\n right = dictionary.word_present?(@word)\n return true if right\n false\n end",
"def checking_dictionary_for_word_match\n valid_word?(@prefix)\n end",
"def has? key, options={}\n !merge_synonym_keys!( key, *options[:syn!] ).nil?\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Output the config settings | def output_config
puts 'Using config file: ' + $CONFIG_FILE
@conf.each { |key, value| puts key + " = " + value }
end | [
"def print_config\n Notify.info(\"Configuration values\")\n\n @config.options.each_pair do |key, value|\n Notify.spit \" - #{key}: #{value}\"\n end\n end",
"def display_config\n # Format types and the additional options that apply to each type\n format_opts = {\n \"bl... | {
"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.