_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 66
10.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q4400
|
TelestreamCloud::Tts.TtsApi.corpus
|
train
|
def corpus(project_id, name, opts = {})
data, _status_code, _headers = corpus_with_http_info(project_id, name, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4401
|
TelestreamCloud::Tts.TtsApi.create_corpus
|
train
|
def create_corpus(project_id, name, body, opts = {})
create_corpus_with_http_info(project_id, name, body, opts)
return nil
end
|
ruby
|
{
"resource": ""
}
|
q4402
|
TelestreamCloud::Tts.TtsApi.create_project
|
train
|
def create_project(project, opts = {})
data, _status_code, _headers = create_project_with_http_info(project, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4403
|
TelestreamCloud::Tts.TtsApi.job
|
train
|
def job(project_id, job_id, opts = {})
data, _status_code, _headers = job_with_http_info(project_id, job_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4404
|
TelestreamCloud::Tts.TtsApi.job_result
|
train
|
def job_result(project_id, job_id, opts = {})
data, _status_code, _headers = job_result_with_http_info(project_id, job_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4405
|
TelestreamCloud::Tts.TtsApi.jobs
|
train
|
def jobs(project_id, opts = {})
data, _status_code, _headers = jobs_with_http_info(project_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4406
|
TelestreamCloud::Tts.TtsApi.project
|
train
|
def project(project_id, opts = {})
data, _status_code, _headers = project_with_http_info(project_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4407
|
TelestreamCloud::Tts.TtsApi.update_project
|
train
|
def update_project(project, opts = {})
data, _status_code, _headers = update_project_with_http_info(project, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4408
|
TelestreamCloud::Tts.TtsApi.upload_video
|
train
|
def upload_video(project_id, video_upload_body, opts = {})
data, _status_code, _headers = upload_video_with_http_info(project_id, video_upload_body, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4409
|
RailsTables::Searching.ClassMethods.search_on
|
train
|
def search_on(column_source, methods)
Array(methods).each do |method_name|
join column_source
self.searches += [{column_source: column_source.to_s, method_name: method_name.to_s}]
end
end
|
ruby
|
{
"resource": ""
}
|
q4410
|
NIFTI.NRead.read_image
|
train
|
def read_image
raw_image = []
@stream.index = @hdr['vox_offset']
type = NIFTI_DATATYPES[@hdr['datatype']]
format = @stream.format[type]
@image_rubyarray = @stream.decode(@stream.rest_length, type)
end
|
ruby
|
{
"resource": ""
}
|
q4411
|
NIFTI.NRead.get_image_narray
|
train
|
def get_image_narray(image_array, dim)
if Object.const_defined?('NArray')
@image_narray = pixel_data = NArray.to_na(image_array).reshape!(*dim[1..dim[0]])
else
add_msg "Can't find NArray, no image_narray created. Please `gem install narray`"
end
end
|
ruby
|
{
"resource": ""
}
|
q4412
|
NIFTI.NRead.parse_header
|
train
|
def parse_header(options = {})
check_header
@hdr = parse_basic_header
@extended_header = parse_extended_header
# Optional image gathering
read_image if options[:image]
get_image_narray(@image_rubyarray, @hdr['dim']) if options[:narray]
@success = true
end
|
ruby
|
{
"resource": ""
}
|
q4413
|
NIFTI.NRead.parse_basic_header
|
train
|
def parse_basic_header
# The HEADER_SIGNATURE is defined in NIFTI::Constants and used for both reading and writing.
header = {}
HEADER_SIGNATURE.each do |header_item|
name, length, type = *header_item
header[name] = @stream.decode(length, type)
end
# Extract Freq, Phase & Slice Dimensions from diminfo
if header['dim_info']
header['freq_dim'] = dim_info_to_freq_dim(header['dim_info'])
header['phase_dim'] = dim_info_to_phase_dim(header['dim_info'])
header['slice_dim'] = dim_info_to_slice_dim(header['dim_info'])
end
header['sform_code_descr'] = XFORM_CODES[header['sform_code']]
header['qform_code_descr'] = XFORM_CODES[header['qform_code']]
return header
end
|
ruby
|
{
"resource": ""
}
|
q4414
|
NIFTI.NRead.parse_extended_header
|
train
|
def parse_extended_header
extended = []
extension = @stream.decode(4, "BY")
# "After the end of the 348 byte header (e.g., after the magic field),
# the next 4 bytes are an byte array field named extension. By default,
# all 4 bytes of this array should be set to zero. In a .nii file, these 4
# bytes will always be present, since the earliest start point for the
# image data is byte #352. In a separate .hdr file, these bytes may or may
# not be present (i.e., a .hdr file may only be 348 bytes long). If not
# present, then a NIfTI-1.1 compliant program should use the default value
# of extension={0,0,0,0}. The first byte (extension[0]) is the only value
# of this array that is specified at present. The other 3 bytes are
# reserved for future use."
if extension[0] != 0
while @stream.index < @hdr['vox_offset']
esize, ecode = *@stream.decode(8, "UL")
data = @stream.decode(esize - 8, "STR")
extended << {:esize => esize, :ecode => ecode, :data => data}
end
# stream.decode(header['vox_offset'] - stream.index, "STR")
# stream.skip header['vox_offset'] - stream.index
end
return extended
end
|
ruby
|
{
"resource": ""
}
|
q4415
|
NIFTI.NRead.open_file
|
train
|
def open_file(file)
if File.exist?(file)
if File.readable?(file)
if not File.directory?(file)
if File.size(file) > 8
begin
@file = Zlib::GzipReader.new(File.new(file, "rb"))
rescue Zlib::GzipFile::Error
@file = File.new(file, "rb")
end
else
@msg << "Error! File is too small to contain DICOM information (#{file})."
end
else
@msg << "Error! File is a directory (#{file})."
end
else
@msg << "Error! File exists but I don't have permission to read it (#{file})."
end
else
@msg << "Error! The file you have supplied does not exist (#{file})."
end
end
|
ruby
|
{
"resource": ""
}
|
q4416
|
Qe.TextField.validation_class
|
train
|
def validation_class(answer_sheet)
validation = ''
validation += ' required' if self.required?(answer_sheet)
# validate-number, etc.
validate_style = ['number', 'currency-dollar', 'email', 'url', 'phone'].find {|v| v == self.style }
if validate_style
validation += ' validate-' + validate_style
end
validation
end
|
ruby
|
{
"resource": ""
}
|
q4417
|
NIFTI.NWrite.write
|
train
|
def write
# Check if we are able to create given file:
open_file(@file_name)
# Go ahead and write if the file was opened successfully:
if @file
# Initiate necessary variables:
init_variables
@file_endian = false
# Create a Stream instance to handle the encoding of content to a binary string:
@stream = Stream.new(nil, @file_endian)
# Tell the Stream instance which file to write to:
@stream.set_file(@file)
# Write Header and Image
write_basic_header
write_extended_header
write_image
# As file has been written successfully, it can be closed.
@file.close
# Mark this write session as successful:
@success = true
end
end
|
ruby
|
{
"resource": ""
}
|
q4418
|
NIFTI.NWrite.write_basic_header
|
train
|
def write_basic_header
HEADER_SIGNATURE.each do |header_item|
begin
name, length, type = *header_item
str = @stream.encode(@obj.header[name], type)
padded_str = @stream.encode_string_to_length(str, length)
# puts @stream.index, name, str.unpack(@stream.vr_to_str(type))
# pp padded_str.unpack(@stream.vr_to_str(type))
@stream.write padded_str
@stream.skip length
rescue StandardError => e
puts name, length, type, e
raise e
end
end
end
|
ruby
|
{
"resource": ""
}
|
q4419
|
NIFTI.NWrite.write_extended_header
|
train
|
def write_extended_header
unless @obj.extended_header.empty?
@stream.write @stream.encode([1,0,0,0], "BY")
@obj.extended_header.each do |extension|
@stream.write @stream.encode extension[:esize], "UL"
@stream.write @stream.encode extension[:ecode], "UL"
@stream.write @stream.encode_string_to_length(@stream.encode(extension[:data], "STR"), extension[:esize] - 8)
end
else
@stream.write @stream.encode([0,0,0,0], "BY")
end
end
|
ruby
|
{
"resource": ""
}
|
q4420
|
VCloudSdk.Powerable.power_on
|
train
|
def power_on
target = entity_xml
class_name = self.class.name.split("::").last
Config.logger.debug "#{class_name} status: #{target[:status]}"
if is_status?(target, :POWERED_ON)
Config.logger.info "#{class_name} #{target.name} is already powered-on."
return
end
power_on_link = target.power_on_link
unless power_on_link
fail CloudError,
"#{class_name} #{target.name} not in a state able to power on."
end
Config.logger.info "Powering on #{class_name} #{target.name}."
task = connection.post(power_on_link.href, nil)
task = monitor_task task, @session.time_limit[:power_on]
Config.logger.info "#{class_name} #{target.name} is powered on."
self
end
|
ruby
|
{
"resource": ""
}
|
q4421
|
VCloudSdk.Powerable.power_off
|
train
|
def power_off
target = entity_xml
class_name = self.class.name.split("::").last
Config.logger.debug "#{class_name} status: #{target[:status]}"
if is_status?(target, :SUSPENDED)
error_msg = "#{class_name} #{target.name} suspended, discard state before powering off."
fail class_name == "VApp" ? VappSuspendedError : VmSuspendedError,
error_msg
end
if is_status?(target, :POWERED_OFF)
Config.logger.info "#{class_name} #{target.name} is already powered off."
return
end
power_off_link = target.power_off_link
unless power_off_link
fail CloudError, "#{class_name} #{target.name} is not in a state that could be powered off."
end
task = connection.post(power_off_link.href, nil)
monitor_task task, @session.time_limit[:power_off]
Config.logger.info "#{class_name} #{target.name} is powered off."
undeploy(target, class_name)
self
end
|
ruby
|
{
"resource": ""
}
|
q4422
|
TelestreamCloud::Flip.FlipApi.cancel_encoding
|
train
|
def cancel_encoding(id, factory_id, opts = {})
data, _status_code, _headers = cancel_encoding_with_http_info(id, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4423
|
TelestreamCloud::Flip.FlipApi.copy_profile
|
train
|
def copy_profile(id, factory_id, copy_profile_body, opts = {})
data, _status_code, _headers = copy_profile_with_http_info(id, factory_id, copy_profile_body, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4424
|
TelestreamCloud::Flip.FlipApi.create_encoding
|
train
|
def create_encoding(factory_id, create_encoding_body, opts = {})
data, _status_code, _headers = create_encoding_with_http_info(factory_id, create_encoding_body, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4425
|
TelestreamCloud::Flip.FlipApi.create_factory
|
train
|
def create_factory(create_factory_body, opts = {})
data, _status_code, _headers = create_factory_with_http_info(create_factory_body, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4426
|
TelestreamCloud::Flip.FlipApi.create_profile
|
train
|
def create_profile(factory_id, create_profile_body, opts = {})
data, _status_code, _headers = create_profile_with_http_info(factory_id, create_profile_body, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4427
|
TelestreamCloud::Flip.FlipApi.create_video
|
train
|
def create_video(factory_id, create_video_body, opts = {})
data, _status_code, _headers = create_video_with_http_info(factory_id, create_video_body, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4428
|
TelestreamCloud::Flip.FlipApi.delete_encoding
|
train
|
def delete_encoding(id, factory_id, opts = {})
data, _status_code, _headers = delete_encoding_with_http_info(id, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4429
|
TelestreamCloud::Flip.FlipApi.delete_profile
|
train
|
def delete_profile(id, factory_id, opts = {})
data, _status_code, _headers = delete_profile_with_http_info(id, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4430
|
TelestreamCloud::Flip.FlipApi.delete_video
|
train
|
def delete_video(id, factory_id, opts = {})
data, _status_code, _headers = delete_video_with_http_info(id, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4431
|
TelestreamCloud::Flip.FlipApi.delete_video_source
|
train
|
def delete_video_source(id, factory_id, opts = {})
data, _status_code, _headers = delete_video_source_with_http_info(id, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4432
|
TelestreamCloud::Flip.FlipApi.encoding
|
train
|
def encoding(id, factory_id, opts = {})
data, _status_code, _headers = encoding_with_http_info(id, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4433
|
TelestreamCloud::Flip.FlipApi.encodings
|
train
|
def encodings(factory_id, opts = {})
data, _status_code, _headers = encodings_with_http_info(factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4434
|
TelestreamCloud::Flip.FlipApi.encodings_count
|
train
|
def encodings_count(factory_id, opts = {})
data, _status_code, _headers = encodings_count_with_http_info(factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4435
|
TelestreamCloud::Flip.FlipApi.factory
|
train
|
def factory(id, opts = {})
data, _status_code, _headers = factory_with_http_info(id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4436
|
TelestreamCloud::Flip.FlipApi.notifications
|
train
|
def notifications(factory_id, opts = {})
data, _status_code, _headers = notifications_with_http_info(factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4437
|
TelestreamCloud::Flip.FlipApi.profile
|
train
|
def profile(id_or_name, factory_id, opts = {})
data, _status_code, _headers = profile_with_http_info(id_or_name, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4438
|
TelestreamCloud::Flip.FlipApi.profile_encodings
|
train
|
def profile_encodings(id_or_name, factory_id, opts = {})
data, _status_code, _headers = profile_encodings_with_http_info(id_or_name, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4439
|
TelestreamCloud::Flip.FlipApi.profiles
|
train
|
def profiles(factory_id, opts = {})
data, _status_code, _headers = profiles_with_http_info(factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4440
|
TelestreamCloud::Flip.FlipApi.queued_videos
|
train
|
def queued_videos(factory_id, opts = {})
data, _status_code, _headers = queued_videos_with_http_info(factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4441
|
TelestreamCloud::Flip.FlipApi.retry_encoding
|
train
|
def retry_encoding(id, factory_id, opts = {})
data, _status_code, _headers = retry_encoding_with_http_info(id, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4442
|
TelestreamCloud::Flip.FlipApi.signed_encoding_url
|
train
|
def signed_encoding_url(id, factory_id, opts = {})
data, _status_code, _headers = signed_encoding_url_with_http_info(id, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4443
|
TelestreamCloud::Flip.FlipApi.signed_encoding_urls
|
train
|
def signed_encoding_urls(id, factory_id, opts = {})
data, _status_code, _headers = signed_encoding_urls_with_http_info(id, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4444
|
TelestreamCloud::Flip.FlipApi.signed_video_url
|
train
|
def signed_video_url(id, factory_id, opts = {})
data, _status_code, _headers = signed_video_url_with_http_info(id, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4445
|
TelestreamCloud::Flip.FlipApi.toggle_factory_sync
|
train
|
def toggle_factory_sync(id, factory_sync_body, opts = {})
data, _status_code, _headers = toggle_factory_sync_with_http_info(id, factory_sync_body, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4446
|
TelestreamCloud::Flip.FlipApi.update_encoding
|
train
|
def update_encoding(id, factory_id, update_encoding_body, opts = {})
data, _status_code, _headers = update_encoding_with_http_info(id, factory_id, update_encoding_body, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4447
|
TelestreamCloud::Flip.FlipApi.update_factory
|
train
|
def update_factory(id, update_factory_body, opts = {})
data, _status_code, _headers = update_factory_with_http_info(id, update_factory_body, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4448
|
TelestreamCloud::Flip.FlipApi.update_notifications
|
train
|
def update_notifications(factory_id, cloud_notification_settings_body, opts = {})
data, _status_code, _headers = update_notifications_with_http_info(factory_id, cloud_notification_settings_body, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4449
|
TelestreamCloud::Flip.FlipApi.update_profile
|
train
|
def update_profile(id, factory_id, update_profile_body, opts = {})
data, _status_code, _headers = update_profile_with_http_info(id, factory_id, update_profile_body, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4450
|
TelestreamCloud::Flip.FlipApi.upload_video
|
train
|
def upload_video(factory_id, video_upload_body, opts = {})
data, _status_code, _headers = upload_video_with_http_info(factory_id, video_upload_body, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4451
|
TelestreamCloud::Flip.FlipApi.video_encodings
|
train
|
def video_encodings(id, factory_id, opts = {})
data, _status_code, _headers = video_encodings_with_http_info(id, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4452
|
TelestreamCloud::Flip.FlipApi.video_metadata
|
train
|
def video_metadata(id, factory_id, opts = {})
data, _status_code, _headers = video_metadata_with_http_info(id, factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4453
|
TelestreamCloud::Flip.FlipApi.videos
|
train
|
def videos(factory_id, opts = {})
data, _status_code, _headers = videos_with_http_info(factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4454
|
TelestreamCloud::Flip.FlipApi.workflows
|
train
|
def workflows(factory_id, opts = {})
data, _status_code, _headers = workflows_with_http_info(factory_id, opts)
return data
end
|
ruby
|
{
"resource": ""
}
|
q4455
|
Comable.ApplicationHelper.liquid_assigns
|
train
|
def liquid_assigns
view_context.assigns.merge(
current_store: current_store,
current_comable_user: current_comable_user,
current_order: current_order,
current_trackers: current_trackers,
form_authenticity_token: form_authenticity_token
).stringify_keys
end
|
ruby
|
{
"resource": ""
}
|
q4456
|
Threshold.Thresholds.flush
|
train
|
def flush
begin
valid_existing_file?(@file)
raise ReadOnlyThresholdsFile if @readonly
hash = current_hash
file = File.open(@file, 'w+')
raise ThresholdAtomicLockFailure, 'The @file state/hash changed before we could flush the file' unless stored_hash == hash
file.write self.sort.to_s
file.close
rescue NonExistantThresholdFile
raise ReadOnlyThresholdsFile if @readonly
file = File.open(@file, 'w')
file.write self.sort.to_s
file.close
end
stored_hash=current_hash
return true
end
|
ruby
|
{
"resource": ""
}
|
q4457
|
Threshold.Thresholds.loadfile
|
train
|
def loadfile
valid_existing_file?(@file)
results = Threshold::Parser.new(@file)
@stored_hash= results.filehash
#puts stored_hash
results.caps.each do |result|
builder = Threshold::Builder.new(result)
self << builder.build
end
end
|
ruby
|
{
"resource": ""
}
|
q4458
|
Threshold.Thresholds.valid?
|
train
|
def valid?
begin
self.each do |threshold|
if threshold.respond_to?(:valid?)
return false unless threshold.valid?
else
raise InvalidThresholdsObject, "Container object has unknown objects"
end
end
return true
rescue InvalidThresholdsObject
return false
end
end
|
ruby
|
{
"resource": ""
}
|
q4459
|
Threshold.Thresholds.uniq
|
train
|
def uniq(&blk)
if block_given?
Thresholds.new(@thresholds.uniq(&blk))
else
Thresholds.new(@thresholds.uniq{ |lineitem| lineitem.to_s(true) })
end
end
|
ruby
|
{
"resource": ""
}
|
q4460
|
Threshold.Thresholds.suppressions
|
train
|
def suppressions(&blk)
if block_given?
self.suppressions.select(&blk)
else
Thresholds.new(@thresholds.select{|t| t.class.to_s == "Threshold::Suppression"})
end
end
|
ruby
|
{
"resource": ""
}
|
q4461
|
Threshold.Thresholds.event_filters
|
train
|
def event_filters(&blk)
if block_given?
self.event_filters.select(&blk)
else
Thresholds.new(@thresholds.select{|t| t.class.to_s == "Threshold::EventFilter"})
end
end
|
ruby
|
{
"resource": ""
}
|
q4462
|
Threshold.Thresholds.rate_filters
|
train
|
def rate_filters(&blk)
if block_given?
self.rate_filters.select(&blk)
else
Thresholds.new(@thresholds.select{|t| t.class.to_s == "Threshold::RateFilter"})
end
end
|
ruby
|
{
"resource": ""
}
|
q4463
|
Backlog.API.count_issue
|
train
|
def count_issue(condition)
raise Backlog::API::ArgumentError, "must specify 'projectId'" unless condition.has_key? "projectId"
condition = Backlog::Object::FindCondition.new(condition)
self.call("backlog.countIssue", condition.to_h)
end
|
ruby
|
{
"resource": ""
}
|
q4464
|
NIFTI.NObject.write
|
train
|
def write(file_name, options={})
if file_name.is_a?(String)
w = NWrite.new(self, file_name, options)
w.write
# Write process succesful?
@write_success = w.success
# If any messages has been recorded, send these to the message handling method:
add_msg(w.msg) if w.msg.length > 0
else
raise ArgumentError, "Invalid file_name. Expected String, got #{file_name.class}."
end
end
|
ruby
|
{
"resource": ""
}
|
q4465
|
NIFTI.NObject.read
|
train
|
def read(string, options={})
if string.is_a?(String)
@string = string
r = NRead.new(string, options)
# Store the data to the instance variables if the readout was a success:
if r.success
@read_success = true
# Update instance variables based on the properties of the NRead object:
@header = r.hdr
@extended_header = r.extended_header
if r.image_narray
@image = r.image_narray
elsif r.image_rubyarray
@image = r.image_rubyarray
end
else
@read_success = false
end
# If any messages have been recorded, send these to the message handling method:
add_msg(r.msg) if r.msg.length > 0
else
raise ArgumentError, "Invalid argument. Expected String, got #{string.class}."
end
end
|
ruby
|
{
"resource": ""
}
|
q4466
|
Qe.QuestionSheet.duplicate
|
train
|
def duplicate
new_sheet = QuestionSheet.new(self.attributes)
new_sheet.label = self.label + ' - COPY'
new_sheet.save(:validate => false)
self.pages.each do |page|
page.copy_to(new_sheet)
end
new_sheet
end
|
ruby
|
{
"resource": ""
}
|
q4467
|
Rubylog.Variable.rubylog_unify
|
train
|
def rubylog_unify other
# check if we are bound
if @bound
# if we are bound
# proceed to our dereferenced value
rubylog_dereference.rubylog_unify(other) do yield end
else
# if we are unbound
# dereference the other
other = other.rubylog_dereference
# if the other is a variable
if other.is_a? Rubylog::Variable
# succeed if same object
(yield; return) if self.equal? other
# we union our guards with the other's
other.append_guards guards do
# and bind to the other
bind_to other do
yield
end
end
else
# if the other is a value
# bind to it and
bind_to other do
# check our guards
if guards.all? {|g|g.rubylog_matches_as_guard? other}
yield
end
end
end
end
end
|
ruby
|
{
"resource": ""
}
|
q4468
|
Qe.ReferenceSheet.send_invite
|
train
|
def send_invite
return if self.email.blank?
application = self.applicant_answer_sheet
Notifier.deliver_notification(self.email,
application.email,
"Reference Invite",
{'reference_full_name' => self.name,
'applicant_full_name' => application.name,
'applicant_email' => application.email,
'applicant_home_phone' => application.phone,
'reference_url' => edit_reference_sheet_url(self, :a => self.access_key, :host => ActionMailer::Base.default_url_options[:host])})
# Send notification to applicant
Notifier.deliver_notification(applicant_answer_sheet.email, # RECIPIENTS
Questionnaire.from_email, # FROM
"Reference Notification to Applicant", # LIQUID TEMPLATE NAME
{'applicant_full_name' => applicant_answer_sheet.name,
'reference_full_name' => self.name,
'reference_email' => self.email,
'application_url' => edit_answer_sheet_url(applicant_answer_sheet, :host => ActionMailer::Base.default_url_options[:host])})
self.email_sent_at = Time.now
self.save(:validate => false)
true
end
|
ruby
|
{
"resource": ""
}
|
q4469
|
UUIDTools.UUID.generate_i
|
train
|
def generate_i
return (begin
bytes = (time_low << 96) + (time_mid << 80) +
(time_hi_and_version << 64) + (clock_seq_hi_and_reserved << 56) +
(clock_seq_low << 48)
for i in 0..5
bytes += (nodes[i] << (40 - (i * 8)))
end
bytes
end)
end
|
ruby
|
{
"resource": ""
}
|
q4470
|
Baidu.Client.authorize_url
|
train
|
def authorize_url(opts = {})
opts[:redirect_uri] ||= DEFAULT_REDIRECT_URI
# scope：非必须参数，以空格分隔的权限列表，若不传递此参数，代表请求用户的默认权限。关于权限的具体信息请参考“权限列表”。
opts[:scope] ||= "basic netdisk super_msg"
oauth_client.auth_code.authorize_url(scope: opts[:scope], redirect_uri: opts[:redirect_uri])
end
|
ruby
|
{
"resource": ""
}
|
q4471
|
Baidu.Client.token!
|
train
|
def token!(authorization_code,opts = {})
opts[:redirect_uri] ||= DEFAULT_REDIRECT_URI
self.access_token = oauth_client.auth_code.get_token(authorization_code, redirect_uri: opts[:redirect_uri])
end
|
ruby
|
{
"resource": ""
}
|
q4472
|
Baidu.Client.refresh_token!
|
train
|
def refresh_token!(refresh_token)
old_token = OAuth2::AccessToken.new(oauth_client,'', refresh_token: refresh_token)
self.access_token = old_token.refresh!
end
|
ruby
|
{
"resource": ""
}
|
q4473
|
MiniSpec.InstanceAPI.stub
|
train
|
def stub object, stub, visibility = nil, &proc
[Symbol, String, Hash].include?(stub.class) ||
raise(ArgumentError, 'a Symbol, String or Hash expected')
if stub.is_a?(Hash)
return hash_stub(object, stub, visibility, &proc)
elsif stub =~ /\./
return chained_stub(object, stub, visibility, &proc)
end
visibility ||= MiniSpec::Utils.method_visibility(object, stub) || :public
stubs = (@__ms__stubs[object.__id__] ||= {})
stubs[stub] ||= MiniSpec::Mocks::Stub.new(object, @__ms__messages, @__ms__stubs__originals)
stubs[stub].stubify(stub, visibility, &proc)
stubs[stub]
end
|
ruby
|
{
"resource": ""
}
|
q4474
|
MiniSpec.InstanceAPI.stubs
|
train
|
def stubs object, *stubs, &proc
MiniSpec::Mocks::MultipleStubsProxy.new(stubs.map {|s| stub(object, s, &proc)})
end
|
ruby
|
{
"resource": ""
}
|
q4475
|
GetnetApi.Card.to_request
|
train
|
def to_request
card = {
number_token: self.number_token,
cardholder_name: self.cardholder_name,
security_code: self.security_code,
brand: self.brand,
expiration_month: self.expiration_month,
expiration_year: self.expiration_year
}
return card
end
|
ruby
|
{
"resource": ""
}
|
q4476
|
CamperVan.Server.post_init
|
train
|
def post_init(*args)
logger.info "got connection from #{remote_ip}"
# initialize the line-based protocol: IRC is \r\n
@lt2_delimiter = "\r\n"
# start up the IRCD for this connection
@ircd = IRCD.new(self, options)
if options[:ssl]
logger.info "starting TLS for #{remote_ip}"
start_tls(:cert_chain_file => options[:ssl_cert], :private_key_file => options[:ssl_private_key], :verify_peer => options[:ssl_verify_peer])
end
end
|
ruby
|
{
"resource": ""
}
|
q4477
|
IPAddrExtensions.ClassMethods.generate_ULA
|
train
|
def generate_ULA(mac, subnet_id = 0, locally_assigned=true)
now = Time.now.utc
ntp_time = ((now.to_i + 2208988800) << 32) + now.nsec # Convert time to an NTP timstamp.
system_id = '::/64'.to_ip.eui_64(mac).to_i # Generate an EUI64 from the provided MAC address.
key = [ ntp_time, system_id ].pack('QQ') # Pack the ntp timestamp and the system_id into a binary string
global_id = Digest::SHA1.digest( key ).unpack('QQ').last & 0xffffffffff # Use only the last 40 bytes of the SHA1 digest.
prefix =
(126 << 121) + # 0xfc (bytes 0..6)
((locally_assigned ? 1 : 0) << 120) + # locally assigned? (byte 7)
(global_id << 80) + # 40 bit global idenfitier (bytes 8..48)
((subnet_id & 0xffff) << 64) # 16 bit subnet_id (bytes 48..64)
prefix.to_ip(Socket::AF_INET6).tap { |p| p.length = 64 }
end
|
ruby
|
{
"resource": ""
}
|
q4478
|
Qe.Admin::QuestionPagesController.show_panel
|
train
|
def show_panel
@tab_name = params[:panel_name]
@panel_name = params[:panel_name] == "properties" ? "prop_sheet" : params[:panel_name]
@all_pages = @question_sheet.pages.find(:all) # for pages_list
@page = @question_sheet.pages.find(params[:id])
respond_to do |format|
format.js # load panel
end
end
|
ruby
|
{
"resource": ""
}
|
q4479
|
Svn.Utils.wrap
|
train
|
def wrap( obj )
ptr = FFI::MemoryPointer.new( :uint64 )
ptr.write_uint64( obj.object_id )
ptr
end
|
ruby
|
{
"resource": ""
}
|
q4480
|
MiniSpec.Utils.method_visibility
|
train
|
def method_visibility object, method
{
public: :public_methods,
protected: :protected_methods,
private: :private_methods
}.each_pair do |v,m|
if v == :public
# in case public_methods overridden to include method
# but method in fact does not exists,
# most notable ActiveRecord::Base#find which rely on method_missing
return v if object.respond_to?(method)
else
return v if object.send(m).include?(method)
end
end
nil
end
|
ruby
|
{
"resource": ""
}
|
q4481
|
MiniSpec.Utils.any_match?
|
train
|
def any_match? label, matchers
reject, select = matchers.partition {|m| m.is_a?(Hash)}
rejected = rejected?(label, reject)
if select.any?
return select.find {|x| (x == :*) || match?(label, x)} && !rejected
end
!rejected
end
|
ruby
|
{
"resource": ""
}
|
q4482
|
MiniSpec.Utils.rejected?
|
train
|
def rejected? label, reject
if reject.any? && (x = reject.first[:except])
if x.is_a?(Array)
return true if x.find {|m| match?(label, m)}
else
return true if match?(label, x)
end
end
false
end
|
ruby
|
{
"resource": ""
}
|
q4483
|
MiniSpec.Utils.match?
|
train
|
def match? label, x
x.is_a?(Regexp) ? label.to_s =~ x : label == x
end
|
ruby
|
{
"resource": ""
}
|
q4484
|
UriSigner.Signer.uri_with_signature
|
train
|
def uri_with_signature
separator = if request_parser.query_params? then '&' else '?' end
encoded_signature = signature.extend(UriSigner::Helpers::String).escaped
"%s%s_signature=%s" % [self.uri, separator, encoded_signature]
end
|
ruby
|
{
"resource": ""
}
|
q4485
|
Polish.Proxies.pluralize
|
train
|
def pluralize(n, *variants)
raise ArgumentError, "Must have a Numeric as a first parameter" unless n.is_a?(Numeric)
raise ArgumentError, "Must have 3 variants for pluralization" if variants.size < 3
variants_hash = pluralization_variants_to_hash(*variants)
I18n.backend.send(:pluralize, LOCALE, variants_hash, n)
end
|
ruby
|
{
"resource": ""
}
|
q4486
|
Qe.Question.set_response
|
train
|
def set_response(values, app)
values = Array.wrap(values)
if !object_name.blank? and !attribute_name.blank?
# if eval("app." + object_name).present?
object = object_name == 'application' ? app : eval("app." + object_name)
unless object.present?
if object_name.include?('.')
objects = object_name.split('.')
object = eval("app." + objects[0..-2].join('.') + ".create_" + objects.last)
eval("app." + objects[0..-2].join('.')).reload
end
end
unless responses(app) == values
value = ActiveRecord::Base.connection.quote_string(values.first)
if self.is_a?(DateField) && value.present?
begin
value = Date.strptime(value, (I18n.t 'date.formats.default'))
rescue
raise "invalid date - " + value.inspect
end
end
object.update_attribute(attribute_name, value)
end
# else
# raise object_name.inspect + ' == ' + attribute_name.inspect
# end
else
@answers ||= []
@mark_for_destroy ||= []
# go through existing answers (in reverse order, as we delete)
(@answers.length - 1).downto(0) do |index|
# reject: skip over responses that are unchanged
unless values.reject! {|value| value == @answers[index]}
# remove any answers that don't match the posted values
@mark_for_destroy << @answers[index] # destroy from database later
@answers.delete_at(index)
end
end
# insert any new answers
for value in values
if @mark_for_destroy.empty?
answer = Answer.new(:question_id => self.id)
else
# re-use marked answers (an update vs. a delete+insert)
answer = @mark_for_destroy.pop
end
answer.set(value)
@answers << answer
end
end
end
|
ruby
|
{
"resource": ""
}
|
q4487
|
Qe.Question.save_response
|
train
|
def save_response(answer_sheet)
unless @answers.nil?
for answer in @answers
if answer.is_a?(Answer)
answer.answer_sheet_id = answer_sheet.id
answer.save!
end
end
end
# remove others
unless @mark_for_destroy.nil?
for answer in @mark_for_destroy
answer.destroy
end
@mark_for_destroy.clear
end
rescue TypeError
raise answer.inspect
end
|
ruby
|
{
"resource": ""
}
|
q4488
|
Qe.Question.has_response?
|
train
|
def has_response?(answer_sheet = nil)
if answer_sheet.present?
answers = responses(answer_sheet)
else
answers = Answer.where(:question_id => self.id)
end
return false if answers.length == 0
answers.each do |answer| # loop through Answers
value = answer.is_a?(Answer) ? answer.value : answer
return true if (value.is_a?(FalseClass) && value === false) || value.present?
end
return false
end
|
ruby
|
{
"resource": ""
}
|
q4489
|
Chars.CharSet.<<
|
train
|
def <<(other)
case other
when String
other.each_char do |char|
byte = char_to_byte(char)
@chars[byte] = char
super(byte)
end
return self
when Integer
super(other)
else
raise(TypeError,"can only append Strings and Integers")
end
end
|
ruby
|
{
"resource": ""
}
|
q4490
|
Chars.CharSet.include_char?
|
train
|
def include_char?(char)
unless char.empty?
@chars.has_value?(char) || include_byte?(char_to_byte(char))
else
false
end
end
|
ruby
|
{
"resource": ""
}
|
q4491
|
Chars.CharSet.each_random_char
|
train
|
def each_random_char(n,&block)
return enum_for(:each_random_char,n) unless block_given?
each_random_byte(n) { |byte| yield @chars[byte] }
end
|
ruby
|
{
"resource": ""
}
|
q4492
|
Chars.CharSet.random_bytes
|
train
|
def random_bytes(length)
if (length.kind_of?(Array) || length.kind_of?(Range))
Array.new(length.sort_by { rand }.first) { random_byte }
else
Array.new(length) { random_byte }
end
end
|
ruby
|
{
"resource": ""
}
|
q4493
|
Chars.CharSet.random_distinct_bytes
|
train
|
def random_distinct_bytes(length)
if (length.kind_of?(Array) || length.kind_of?(Range))
self.entries.sort_by { rand }.slice(0...(length.sort_by { rand }.first))
else
self.entries.sort_by { rand }.slice(0...length)
end
end
|
ruby
|
{
"resource": ""
}
|
q4494
|
Chars.CharSet.strings_in
|
train
|
def strings_in(data,options={},&block)
unless block
if options[:offsets]
found = {}
block = lambda { |offset,substring| found[offset] = substring }
else
found = []
block = lambda { |substring| found << substring }
end
strings_in(data,options,&block)
return found
end
min_length = options.fetch(:length,4)
return if data.length < min_length
index = 0
while index <= (data.length - min_length)
if self === data[index,min_length]
sub_index = (index + min_length)
while self.include_char?(data[sub_index,1])
sub_index += 1
end
match = data[index...sub_index]
case block.arity
when 2
yield match, index
else
yield match
end
index = sub_index
else
index += 1
end
end
end
|
ruby
|
{
"resource": ""
}
|
q4495
|
HasOffersModel.ClassMethods.has_offers_model
|
train
|
def has_offers_model(has_offers_class_name)
has_offers_class = "HasOffers::#{has_offers_class_name}".constantize
class_eval do
define_method("has_offers_create") do
if respond_to? :has_offer_id
response = has_offers_class.create(has_offers_params)
if response.success?
if response.data.is_a? Hash
# return_object is true
self.has_offer_id = response.data[has_offers_class_name]["id"].to_i
else
# return_object is false
self.has_offer_id = response.data.to_i
end
end
check_for_errors(response)
end
end
define_method("has_offers_update") do
if respond_to?(:has_offer_id) and has_offer_id
response = has_offers_class.update(has_offer_id, has_offers_params)
check_for_errors(response)
end
end
define_method("check_for_errors") do |response|
unless response.success?
response.error_messages.each do |error_message|
new_error_message = "HasOffers API Error: #{error_message}"
if self.errors.respond_to?(:add_to_base)
self.errors.add_to_base new_error_message
else
self.errors.add :base, new_error_message
end
end
end
response.success?
end
end
end
|
ruby
|
{
"resource": ""
}
|
q4496
|
Diameter.AVP.inner_avps
|
train
|
def inner_avps(name)
code, _type, _vendor = AVPNames.get(name)
grouped_value.select { |a| a.code == code }
end
|
ruby
|
{
"resource": ""
}
|
q4497
|
Diameter.AVP.ip_address=
|
train
|
def ip_address=(value)
bytes = if value.ipv4?
[1].pack('n')
else
[2].pack('n')
end
bytes += value.hton
@content = bytes
end
|
ruby
|
{
"resource": ""
}
|
q4498
|
MiniSpec.InstanceAPI.double
|
train
|
def double *args, &proc
name = args.first.is_a?(Hash) ? nil : args.shift
object = Object.new
object.define_singleton_method(:__ms__double_instance) {true}
object.define_singleton_method(:inspect) {name} if name
hashes, rest = args.partition {|s| s.is_a?(Hash)}
hashes.each {|h| stub(object, h)}
rest.each {|s| stub(object, s, &proc)}
object
end
|
ruby
|
{
"resource": ""
}
|
q4499
|
QontoOfx.Converter.convert
|
train
|
def convert(remove_ns = false)
organization = @gateway.fetch_organization['organization']
builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8')
builder[:ofx].OFX('xmlns:ofx' => 'http://ofx.net/types/2003/04') do |xml|
add_signonmsgsrsv1_block xml
xml.BANKMSGSRSV1 do
xml.parent.namespace = nil
organization['bank_accounts'].each do |bank_account|
xml.STMTTRNRS do
xml.TRNUID 1
add_status_block xml
xml.STMTRS do
xml.CURDEF 'EUR'
add_bankacctfrom_block xml, bank_account
xml.BANKTRANLIST do
process_transactions xml, bank_account
end
xml.LEDGERBAL do
xml.BALAMT bank_account['balance']
xml.DTASOF Time.now.strftime('%Y%m%d%H%M%S')
end
end
end
end
end
end
move_to_first_position(builder, '//DTEND')
move_to_first_position(builder, '//DTSTART')
result = builder.to_xml
raise 'generation failed (invalid OFX)' unless @ofx_validator.valid? result
result = result.gsub(
'ofx:OFX',
'OFX'
).gsub(' xmlns:ofx="http://ofx.net/types/2003/04"', '') if remove_ns
result
end
|
ruby
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.