_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q17600 | Elastomer::Client::RestApiSpec.ApiSpec.valid_param? | train | def valid_param?(api:, param:)
rest_api = get(api)
return true if | ruby | {
"resource": ""
} |
q17601 | Elastomer::Client::RestApiSpec.ApiSpec.select_parts | train | def select_parts(api:, from:)
rest_api = get(api)
| ruby | {
"resource": ""
} |
q17602 | Elastomer::Client::RestApiSpec.ApiSpec.valid_part? | train | def valid_part?(api:, part:)
rest_api = get(api)
return true if | ruby | {
"resource": ""
} |
q17603 | Elastomer::Client::RestApiSpec.ApiSpec.select_common_params | train | def select_common_params(from:)
return from if | ruby | {
"resource": ""
} |
q17604 | Elastomer::Client::RestApiSpec.ApiSpec.validate_params! | train | def validate_params!(api:, params:)
rest_api = get(api)
return params if rest_api.nil?
params.keys.each do |key|
unless rest_api.valid_param?(key) || valid_common_param?(key)
| ruby | {
"resource": ""
} |
q17605 | Elastomer.Client.multi_search | train | def multi_search(body = nil, params = nil)
if block_given?
params, body = (body || {}), nil
yield msearch_obj = MultiSearch.new(self, params)
msearch_obj.call
else
raise "multi_search request body cannot be nil" if body.nil?
params ||= {}
| ruby | {
"resource": ""
} |
q17606 | Elastomer.Client.multi_percolate | train | def multi_percolate(body = nil, params = nil)
if block_given?
params, body = (body || {}), nil
yield mpercolate_obj = MultiPercolate.new(self, params)
mpercolate_obj.call
else
raise "multi_percolate request body cannot be nil" if body.nil?
params ||= {}
| ruby | {
"resource": ""
} |
q17607 | Elastomer.Client.bulk | train | def bulk( body = nil, params = nil )
if block_given?
params, body = (body || {}), nil
yield bulk_obj = Bulk.new(self, params)
bulk_obj.call
else
raise "bulk request body cannot be nil" if body.nil?
params ||= {} | ruby | {
"resource": ""
} |
q17608 | Elastomer.Client.bulk_stream_responses | train | def bulk_stream_responses(ops, params = {})
bulk_obj = Bulk.new(self, params)
Enumerator.new do |yielder|
ops.each do |action, *args|
| ruby | {
"resource": ""
} |
q17609 | Elastomer.Client.bulk_stream_items | train | def bulk_stream_items(ops, params = {})
stats = {
"took" => 0,
"errors" => false,
"success" => 0,
"failure" => 0
}
bulk_stream_responses(ops, params).each do |response|
stats["took"] += response["took"]
stats["errors"] |= response["errors"]
res... | ruby | {
"resource": ""
} |
q17610 | Representors.Representor.identifier | train | def identifier
@identifier ||= begin
uri = @representor_hash.href || self.object_id
protocol | ruby | {
"resource": ""
} |
q17611 | RepresentorSupport.Utilities.symbolize_keys | train | def symbolize_keys(hash)
| ruby | {
"resource": ""
} |
q17612 | Representors.HaleDeserializer.deserialize_embedded | train | def deserialize_embedded(builder, media)
make_embedded_resource = ->(x) { self.class.new(x).to_representor_hash.to_h }
(media[EMBEDDED_KEY] || | ruby | {
"resource": ""
} |
q17613 | Representors.RepresentorBuilder.add_attribute | train | def add_attribute(name, value, options={})
new_representor_hash = RepresentorHash.new(deep_dup(@representor_hash.to_h)) | ruby | {
"resource": ""
} |
q17614 | Representors.RepresentorBuilder.add_transition | train | def add_transition(rel, href, options={})
new_representor_hash = RepresentorHash.new(deep_dup(@representor_hash.to_h))
options = symbolize_keys(options)
options.delete(:method) if options[:method] == Transition::DEFAULT_METHOD | ruby | {
"resource": ""
} |
q17615 | Representors.RepresentorBuilder.add_transition_array | train | def add_transition_array(rel, array_of_hashes)
array_of_hashes.reduce(RepresentorBuilder.new(@representor_hash)) do |memo, transition|
transition = symbolize_keys(transition)
| ruby | {
"resource": ""
} |
q17616 | ActiveRecord.OracleEnhancedProcedures._create_record | train | def _create_record
# check if class has custom create method
if self.class.custom_create_method
# run before/after callbacks defined in model
run_callbacks(:create) do
# timestamp
if self.record_timestamps
current_time = current_time_from_proper_... | ruby | {
"resource": ""
} |
q17617 | ActiveRecord.OracleEnhancedProcedures._update_record | train | def _update_record(attribute_names = @attributes.keys)
# check if class has custom update method
if self.class.custom_update_method
# run before/after callbacks defined in model
run_callbacks(:update) do
# timestamp
if should_record_timestamps?
c... | ruby | {
"resource": ""
} |
q17618 | Recurly.Coupon.redeem | train | def redeem account_or_code, currency = nil, extra_opts={}
return false unless link? :redeem
account_code = if account_or_code.is_a? Account
account_or_code.account_code
else
account_or_code
end
redemption_options = {
:account_code => account_code,
:currenc... | ruby | {
"resource": ""
} |
q17619 | Recurly.Coupon.generate | train | def generate(amount)
builder = XML.new("<coupon/>")
builder.add_element 'number_of_unique_codes', amount
| ruby | {
"resource": ""
} |
q17620 | Recurly.Coupon.redeem! | train | def redeem!(account_code, currency = nil)
redemption = redeem(account_code, currency)
raise Invalid.new(self) | ruby | {
"resource": ""
} |
q17621 | Recurly.Resource.read_attribute | train | def read_attribute(key)
key = key.to_s
if attributes.key? key
value = attributes[key]
elsif links.key?(key) && | ruby | {
"resource": ""
} |
q17622 | Recurly.Resource.write_attribute | train | def write_attribute(key, value)
if changed_attributes.key?(key = key.to_s)
changed_attributes.delete key if changed_attributes[key] == value
elsif self[key] != value
changed_attributes[key] = self[key]
end
association = self.class.find_association(key)
if association
... | ruby | {
"resource": ""
} |
q17623 | Recurly.Resource.attributes= | train | def attributes=(attributes = {})
attributes.each_pair { |k, v|
| ruby | {
"resource": ""
} |
q17624 | Recurly.Resource.follow_link | train | def follow_link(key, options = {})
if link = links[key = key.to_s]
response = API.send link[:method], link[:href], options[:body], options
if resource_class = link[:resource_class]
response = resource_class.from_response response
| ruby | {
"resource": ""
} |
q17625 | Recurly.Resource.to_xml | train | def to_xml(options = {})
builder = options[:builder] || XML.new("<#{self.class.member_name}/>")
xml_keys.each { |key|
value = respond_to?(key) ? send(key) : self[key]
node = builder.add_element key
# Duck-typing here is problematic because of ActiveSupport's #to_xml.
case va... | ruby | {
"resource": ""
} |
q17626 | Recurly.Resource.save | train | def save
if new_record? || changed?
clear_errors
@response = API.send(
persisted? ? :put : :post, path, to_xml
)
reload response
persist! true
end
| ruby | {
"resource": ""
} |
q17627 | Recurly.Resource.destroy | train | def destroy
return false unless persisted?
@response = API.delete uri | ruby | {
"resource": ""
} |
q17628 | Recurly.Account.invoice! | train | def invoice!(attrs={})
InvoiceCollection.from_response API.post(invoices.uri, attrs.empty? ? nil : Invoice.to_xml(attrs))
rescue | ruby | {
"resource": ""
} |
q17629 | Recurly.Account.build_invoice | train | def build_invoice
InvoiceCollection.from_response API.post("#{invoices.uri}/preview")
| ruby | {
"resource": ""
} |
q17630 | Recurly.Account.verify_cvv! | train | def verify_cvv!(verification_value)
bi = BillingInfo.new(verification_value: verification_value)
bi.uri = | ruby | {
"resource": ""
} |
q17631 | Recurly.Invoice.enter_offline_payment | train | def enter_offline_payment(attrs={})
Transaction.from_response API.post("#{uri}/transactions", attrs.empty? ? nil : Transaction.to_xml(attrs))
| ruby | {
"resource": ""
} |
q17632 | Recurly.GiftCard.preview | train | def preview
clear_errors
@response = API.send(:post, "#{path}/preview", to_xml)
reload response | ruby | {
"resource": ""
} |
q17633 | Recurly.Subscription.postpone | train | def postpone next_renewal_date, bulk=false
return false unless link? :postpone
reload follow_link(:postpone,
| ruby | {
"resource": ""
} |
q17634 | Recurly.Subscription.update_notes | train | def update_notes(notes)
return false unless link? :notes
| ruby | {
"resource": ""
} |
q17635 | Recurly.Subscription.pause | train | def pause(remaining_pause_cycles)
builder = XML.new("<subscription/>")
builder.add_element('remaining_pause_cycles', remaining_pause_cycles)
| ruby | {
"resource": ""
} |
q17636 | Recurly.XML.add_element | train | def add_element name, value = nil
value = value.respond_to?(:xmlschema) | ruby | {
"resource": ""
} |
q17637 | RSpec::Puppet.Coverage.add_from_catalog | train | def add_from_catalog(catalog, test_module)
coverable_resources = catalog.to_a.reject { |resource| !test_module.nil? && filter_resource?(resource, test_module) }
| ruby | {
"resource": ""
} |
q17638 | RSpec::Puppet.Coverage.filter_resource? | train | def filter_resource?(resource, test_module)
if @filters.include?(resource.to_s)
return true
end
if resource.type == 'Class'
module_name = resource.title.split('::').first.downcase
if module_name != test_module
return true
end
| ruby | {
"resource": ""
} |
q17639 | RSpec::Puppet.Coverage.module_paths | train | def module_paths(test_module)
adapter = RSpec.configuration.adapter
paths = adapter.modulepath.map do |dir|
File.join(dir, test_module, 'manifests')
| ruby | {
"resource": ""
} |
q17640 | RSpec::Puppet.FunctionExampleGroup.build_compiler | train | def build_compiler
node_name = nodename(:function)
fact_values = facts_hash(node_name)
trusted_values = trusted_facts_hash(node_name)
# Allow different Hiera configurations:
HieraPuppet.instance_variable_set('@hiera', nil) if defined? HieraPuppet
# if we specify a pre_condition, ... | ruby | {
"resource": ""
} |
q17641 | Lvm2Thin.SuperBlock.device_to_data | train | def device_to_data(device_id, pos, len)
dev_blk = device_block(pos)
dev_off = device_block_offset(pos)
data_map = data_mapping.map_for(device_id)
total_len = 0
data_blks = []
num_data_blks = (len / data_block_size).to_i + 1
0.upto(num_data_blks - 1) do |i|
current_b... | ruby | {
"resource": ""
} |
q17642 | NTFS.AttributeList.loadAttributes | train | def loadAttributes(attribType)
result = []
# ad is an attribute descriptor.
@list.each do |ad|
next unless ad['attrib_type'] == attribType
# Load referenced attribute and add | ruby | {
"resource": ""
} |
q17643 | NTFS.AttribData.read | train | def read(bytes = @length)
return nil if @pos >= @length
bytes = @length - @pos if bytes.nil?
bytes = @length - @pos if @pos | ruby | {
"resource": ""
} |
q17644 | Fat32.BootSect.getNextCluster | train | def getNextCluster(clus)
nxt = getFatEntry(clus)
return nil if nxt > CC_END_OF_CHAIN
raise "Damaged | ruby | {
"resource": ""
} |
q17645 | Fat32.BootSect.countContigClusters | train | def countContigClusters(clus)
cur = clus; nxt = 0
loop do
nxt = getFatEntry(cur)
break if nxt != cur + 1
cur = nxt; redo
end
raise | ruby | {
"resource": ""
} |
q17646 | Fat32.BootSect.wipeChain | train | def wipeChain(clus)
loop do
nxt = getFatEntry(clus)
putFatEntry(clus, 0)
break if nxt == 0 # A 0 entry means FAT is inconsistent. Chkdsk may report lost clusters.
break if nxt == CC_DAMAGED | ruby | {
"resource": ""
} |
q17647 | Fat32.BootSect.writeClusters | train | def writeClusters(start, buf, len = buf.length)
clus = start; num, leftover = len.divmod(@bytesPerCluster); num += 1 if leftover > 0
0.upto(num - 1) do |offset|
local = buf[offset * @bytesPerCluster, @bytesPerCluster]
if local.length < @bytesPerCluster then local += ("\0" * (@bytesPerCluster... | ruby | {
"resource": ""
} |
q17648 | Fat32.BootSect.putFatEntry | train | def putFatEntry(clus, value)
raise "DONT TOUCH THIS CLUSTER: #{clus}" if clus < | ruby | {
"resource": ""
} |
q17649 | NTFS.BootSect.clusterInfo | train | def clusterInfo
return @clusterInfo unless @clusterInfo.nil?
# MFT Entry 6 ==> BITMAP Information
ad = mftEntry(6).attributeData
data = ad.read(ad.length)
ad.rewind
c = data.unpack("b#{data.length * 8}")[0]
nclusters = c.length
on = | ruby | {
"resource": ""
} |
q17650 | NTFS.BootSect.mftRecToBytePos | train | def mftRecToBytePos(recno)
# Return start of mft if rec 0 (no point in the rest of this).
return mftLoc if recno == 0
# Find which fragment contains the target mft record.
start = fragTable[0]; last_clusters = 0; target_cluster = recno * @bytesPerFileRec / @bytesPerCluster
if (recno > @by... | ruby | {
"resource": ""
} |
q17651 | NTFS.DirectoryIndexNode.dump | train | def dump
out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
out << " Mft Ref : seq #{@refMft[0]}, entry #{@refMft[1]}\n"
out << " Length : #{@length}\n"
out << " Content : #{@contentLen}\n"
out << " Flags : 0x#{'%08x' % @flags}\n"
| ruby | {
"resource": ""
} |
q17652 | Ext4.Directory.globEntriesByHashTree | train | def globEntriesByHashTree
ents_by_name = {}
offset = 0
# Chomp fake '.' and '..' directories first
2.times do
de = DirectoryEntry.new(@data[offset..-1], @sb.isNewDirEnt?)
ents_by_name[de.name] ||= []
ents_by_name[de.name] << de
offset += 12
end
$log.i... | ruby | {
"resource": ""
} |
q17653 | MiqBerkeleyDB.MiqBdbPage.dump | train | def dump
out = ""
out << "Page #{current}\n"
out << " type: #{MiqBdbPage.type2string(ptype)}\n"
out << " prev: #{prev}\n"
out << " next: #{@header['next_pgno']}\n"
out << " log seq num: file=#{@header['lsn_file']} offset=#{@header['lsn_offse... | ruby | {
"resource": ""
} |
q17654 | NTFS.IndexRoot.find | train | def find(name)
log_prefix = "MIQ(NTFS::IndexRoot.find)"
name = name.downcase
$log.debug "#{log_prefix} Searching for [#{name}]" if DEBUG_TRACE_FIND
if @foundEntries.key?(name)
$log.debug "#{log_prefix} Found [#{name}] (cached)" if DEBUG_TRACE_FIND
return @foundEntries[name]
... | ruby | {
"resource": ""
} |
q17655 | NTFS.IndexRoot.globNames | train | def globNames
@globNames = globEntries.collect { |e| e.namespace == NTFS::FileName::NS_DOS ? nil | ruby | {
"resource": ""
} |
q17656 | ReiserFS.Block.getKey | train | def getKey(k)
return nil if k > @nitems || k <= 0
pos = SIZEOF_BLOCK_HEADER + (SIZEOF_KEY * (k - 1))
| ruby | {
"resource": ""
} |
q17657 | ReiserFS.Block.getPointer | train | def getPointer(p)
# puts "getPointer >> p=#{p}"
return nil if p > @nitems || p < 0
pos = SIZEOF_BLOCK_HEADER + (SIZEOF_KEY * @nitems) + (SIZEOF_POINTER * | ruby | {
"resource": ""
} |
q17658 | Iso9660.BootSector.dump | train | def dump
out = "\n"
out += "Type : #{@bs['desc_type']}\n"
out += "Record ID : #{@bs['id']}\n"
out += "Version : #{@bs['version']}\n"
out += "System ID : #{@bs['system_id'].strip}\n"
out += "Volume ID : #{@volName}\n"
out += "Vol space size ... | ruby | {
"resource": ""
} |
q17659 | XFS.Inode.bmap_btree_record_to_block_pointers | train | def bmap_btree_record_to_block_pointers(record, block_pointers_length)
block_pointers = []
# Fill in the missing blocks with 0-blocks
block_pointers << | ruby | {
"resource": ""
} |
q17660 | MiqLinux.Packages.procRPM | train | def procRPM(dbDir)
$log.debug "Processing RPM package database"
rpmp | ruby | {
"resource": ""
} |
q17661 | MiqLinux.Packages.procConary | train | def procConary(dbFile)
$log.debug "Processing Conary package database"
| ruby | {
"resource": ""
} |
q17662 | MiqWin32.System.os_product_suite | train | def os_product_suite(hash)
eid = hash.delete(:edition_id)
ps = hash.delete(:product_suite)
# If edition_id is populated then the edition will already be part of the product_name string
| ruby | {
"resource": ""
} |
q17663 | Wice.GridOutputBuffer.add_filter | train | def add_filter(detach_with_id, filter_code)
raise WiceGridException.new("Detached | ruby | {
"resource": ""
} |
q17664 | Wice.GridOutputBuffer.filter_for | train | def filter_for(detach_with_id)
unless @filters.key? detach_with_id
if @return_empty_strings_for_nonexistent_filters
return ''
else
raise WiceGridException.new("No filter with Detached ID '#{detach_with_id}'!")
end
end
unless @filters[detach_with_id]
... | ruby | {
"resource": ""
} |
q17665 | Wice.Controller.export_grid_if_requested | train | def export_grid_if_requested(opts = {})
grid = self.wice_grid_instances.detect(&:output_csv?)
if grid
template_name = opts[grid.name] || opts[grid.name.intern]
template_name ||= grid.name + '_grid'
temp_filename = render_to_string(partial: template_name)
temp_filename = temp... | ruby | {
"resource": ""
} |
q17666 | Wice.Controller.wice_grid_custom_filter_params | train | def wice_grid_custom_filter_params(opts = {})
options = {
grid_name: 'grid',
attribute: nil,
model: nil,
value: nil
}
options.merge!(opts)
[:attribute, :value].each do |key|
raise ::Wice::WiceGridArgumentError.new("wice_grid_custom_filter_params: ... | ruby | {
"resource": ""
} |
q17667 | Wice.GridViewHelper.dump_filter_parameters_as_hidden_fields | train | def dump_filter_parameters_as_hidden_fields(grid)
unless grid.is_a? WiceGrid
raise WiceGridArgumentError.new('dump_filter_parameters_as_hidden_fields: the parameter must be a WiceGrid instance.')
end
| ruby | {
"resource": ""
} |
q17668 | Wice.GridViewHelper.filter_and_order_state_as_hash | train | def filter_and_order_state_as_hash(grid)
{
grid.name => {
'f' => grid.status[:f],
| ruby | {
"resource": ""
} |
q17669 | Wice.GridViewHelper.scaffolded_grid | train | def scaffolded_grid(grid_obj, opts = {}) #:nodoc:
unless grid_obj.is_a? WiceGrid
raise WiceGridArgumentError.new('scaffolded_grid: the parameter must be a WiceGrid instance.')
end
# debug grid.klass.column_names
columns = grid_obj.klass.column_names
if opts[:reject_attributes].is_... | ruby | {
"resource": ""
} |
q17670 | Wice.GridRenderer.action_column | train | def action_column(opts = {}, &block)
if @action_column_present
raise Wice::WiceGridException.new('There can be only one action column in a WiceGrid')
end
options = {
param_name: :selected,
html: {},
select_all_buttons: true,
object_prop... | ruby | {
"resource": ""
} |
q17671 | Wice.WiceGrid.distinct_values_for_column | train | def distinct_values_for_column(column) #:nodoc:
column.model.select("distinct #{column.name}").order("#{column.name} asc").collect do|ar|
| ruby | {
"resource": ""
} |
q17672 | Wice.GridViewHelper.grid | train | def grid(grid, opts = {}, &block)
raise WiceGridArgumentError.new('Missing block for the grid helper.' \
' For detached filters use first define_grid with the same API as grid, ' \
'then | ruby | {
"resource": ""
} |
q17673 | SmartListing.Helper.smart_listing_for | train | def smart_listing_for name, *args, &block
raise ArgumentError, "Missing block" unless block_given?
name = name.to_sym
options = args.extract_options!
bare = options.delete(:bare)
builder = Builder.new(name, @smart_listings[name], self, options, block)
output = ""
data = {}
... | ruby | {
"resource": ""
} |
q17674 | Coach.Handler.build_request_chain | train | def build_request_chain(sequence, context)
sequence.reverse.reduce(nil) do |successor, item|
| ruby | {
"resource": ""
} |
q17675 | Coach.Handler.dedup_sequence | train | def dedup_sequence(sequence)
sequence.uniq | ruby | {
"resource": ""
} |
q17676 | Coach.Router.action_traits | train | def action_traits(list_of_actions)
*list_of_actions, traits = list_of_actions if list_of_actions.last.is_a?(Hash)
list_of_actions.reduce(traits || {}) do |memo, action|
trait = ACTION_TRAITS.fetch(action) do
| ruby | {
"resource": ""
} |
q17677 | Coach.Middleware.provide | train | def provide(args)
args.each do |name, value|
unless self.class.provides?(name)
| ruby | {
"resource": ""
} |
q17678 | Coach.Middleware.instrument | train | def instrument
proc do
publish_start
if ActiveSupport::Notifications.notifier.listening?("coach.middleware.finish")
instrument_deprecated { call }
else
ActiveSupport::Notifications.
| ruby | {
"resource": ""
} |
q17679 | Coach.MiddlewareValidator.validated_provides! | train | def validated_provides!
if missing_requirements.any?
raise Coach::Errors::MiddlewareDependencyNotMet.new(
| ruby | {
"resource": ""
} |
q17680 | Coach.RequestBenchmark.stats | train | def stats
{
endpoint_name: @endpoint_name,
started_at: @start,
duration: format_ms(@duration),
chain: sorted_chain.map do |event|
| ruby | {
"resource": ""
} |
q17681 | Coach.Notifications.broadcast | train | def broadcast(event, benchmark)
serialized = RequestSerializer.new(event[:request]).serialize.
merge(benchmark.stats).
merge(event.slice(:response, :metadata))
if ActiveSupport::Notifications.notifier.listening?("coach.request")
ActiveSupport::Deprecation.warn("The 'coach.request' ev... | ruby | {
"resource": ""
} |
q17682 | TwitterAds.LineItem.targeting_criteria | train | def targeting_criteria(id = nil, opts = {})
id ? TargetingCriteria.load(account, | ruby | {
"resource": ""
} |
q17683 | TwitterAds.Cursor.each | train | def each(offset = 0)
return to_enum(:each, offset) unless block_given?
@collection[offset..-1].each { |element| yield(element) }
unless exhausted?
| ruby | {
"resource": ""
} |
q17684 | TwitterAds.Metrics.filter | train | def filter(*line_items)
result = {}
params = { line_item_ids: line_items.join(','), with_deleted: true }
@account.line_items(nil, params).each do |line_item|
# filter by objective
objective = line_item.objective.downcase.to_sym
metrics = OBJECTIVES[objective].map { |family| M... | ruby | {
"resource": ""
} |
q17685 | TwitterAds.Account.features | train | def features
validate_loaded
resource = FEATURES % { id: @id }
response | ruby | {
"resource": ""
} |
q17686 | TwitterAds.Account.scoped_timeline | train | def scoped_timeline(ids, opts = {})
ids = ids.join(',') if ids.is_a?(Array)
params = { user_ids: ids }.merge!(opts)
resource = SCOPED_TIMELINE % { id: @id }
| ruby | {
"resource": ""
} |
q17687 | TwitterAds.Persistence.save | train | def save
if @id
resource = self.class::RESOURCE % { account_id: account.id, id: id }
response = Request.new(account.client, :put, resource, params: to_params).perform
| ruby | {
"resource": ""
} |
q17688 | TwitterAds.Persistence.delete! | train | def delete!
resource = self.class::RESOURCE % { account_id: account.id, id: id }
response = | ruby | {
"resource": ""
} |
q17689 | TwitterAds.TONUpload.perform | train | def perform
if @file_size < SINGLE_UPLOAD_MAX
resource = "#{DEFAULT_RESOURCE}#{@bucket}"
response = upload(resource, File.read(@file_path))
response.headers['location'][0]
else
response = init_chunked_upload
bytes_per_chunk_size = response.headers['x-ton-min-chunk-siz... | ruby | {
"resource": ""
} |
q17690 | TwitterAds.TONUpload.upload | train | def upload(resource, bytes)
headers = {
'x-ton-expires' => DEFAULT_EXPIRE,
'content-length' => @file_size,
| ruby | {
"resource": ""
} |
q17691 | TwitterAds.TONUpload.init_chunked_upload | train | def init_chunked_upload
headers = {
'x-ton-content-type' => content_type,
'x-ton-content-length' => @file_size,
'x-ton-expires' => DEFAULT_EXPIRE,
'content-length' => 0,
'content-type' => content_type | ruby | {
"resource": ""
} |
q17692 | TwitterAds.TONUpload.upload_chunk | train | def upload_chunk(resource, bytes, bytes_start, bytes_read)
headers = {
'content-type' => content_type,
'content-length' => bytes.size,
'content-range' => "bytes #{bytes_start}-#{bytes_read - 1}/#{@file_size}"
}
| ruby | {
"resource": ""
} |
q17693 | TwitterAds.TailoredAudience.update | train | def update(file_path, list_type, operation = 'ADD')
upload = TwitterAds::TONUpload.new(account.client, | ruby | {
"resource": ""
} |
q17694 | TwitterAds.TailoredAudience.status | train | def status
return nil unless id
resource = RESOURCE_UPDATE % { account_id: account.id }
request = Request.new(account.client, :get, resource, params: to_params)
| ruby | {
"resource": ""
} |
q17695 | TwitterAds.TailoredAudience.users | train | def users(params)
resource = RESOURCE_USERS % { account_id: account.id, id: id }
headers = { 'Content-Type' => 'application/json' }
response = TwitterAds::Request.new(account.client,
:post, | ruby | {
"resource": ""
} |
q17696 | TwitterAds.Client.accounts | train | def accounts(id = nil, opts = {})
id ? Account.load(self, id) : | ruby | {
"resource": ""
} |
q17697 | MetaSearch.Method.evaluate | train | def evaluate(relation, param)
if splat_param?
relation.send(name, *format_param(param)) | ruby | {
"resource": ""
} |
q17698 | Webrat.Scope.fill_in | train | def fill_in(field_locator, options = {})
field = locate_field(field_locator, TextField, TextareaField, PasswordField)
| ruby | {
"resource": ""
} |
q17699 | Webrat.Matchers.assert_contain | train | def assert_contain(content)
hc = HasContent.new(content) | ruby | {
"resource": ""
} |
Subsets and Splits
SQL Console for CoIR-Retrieval/CodeSearchNet-ccr-ruby-queries-corpus
Retrieves a large number of entries in the 'ruby' language, providing basic information but limited analytical value.