_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 66
10.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q1800
|
Rinda.TupleBag.delete
|
train
|
def delete(tuple)
key = bin_key(tuple)
bin = @hash[key]
return nil unless bin
bin.delete(tuple)
@hash.delete(key) if bin.empty?
tuple
end
|
ruby
|
{
"resource": ""
}
|
q1801
|
Rinda.TupleBag.find_all
|
train
|
def find_all(template)
bin_for_find(template).find_all do |tuple|
tuple.alive? && template.match(tuple)
end
end
|
ruby
|
{
"resource": ""
}
|
q1802
|
Rinda.TupleBag.find
|
train
|
def find(template)
bin_for_find(template).find do |tuple|
tuple.alive? && template.match(tuple)
end
end
|
ruby
|
{
"resource": ""
}
|
q1803
|
Rinda.TupleBag.delete_unless_alive
|
train
|
def delete_unless_alive
deleted = []
@hash.each do |key, bin|
bin.delete_if do |tuple|
if tuple.alive?
false
else
deleted.push(tuple)
true
end
end
end
deleted
end
|
ruby
|
{
"resource": ""
}
|
q1804
|
Rinda.TupleSpace.write
|
train
|
def write(tuple, sec=nil)
entry = create_entry(tuple, sec)
synchronize do
if entry.expired?
@read_waiter.find_all_template(entry).each do |template|
template.read(tuple)
end
notify_event('write', entry.value)
notify_event('delete', entry.value)
else
@bag.push(entry)
start_keeper if entry.expires
@read_waiter.find_all_template(entry).each do |template|
template.read(tuple)
end
@take_waiter.find_all_template(entry).each do |template|
template.signal
end
notify_event('write', entry.value)
end
end
entry
end
|
ruby
|
{
"resource": ""
}
|
q1805
|
Rinda.TupleSpace.move
|
train
|
def move(port, tuple, sec=nil)
template = WaitTemplateEntry.new(self, tuple, sec)
yield(template) if block_given?
synchronize do
entry = @bag.find(template)
if entry
port.push(entry.value) if port
@bag.delete(entry)
notify_event('take', entry.value)
return entry.value
end
raise RequestExpiredError if template.expired?
begin
@take_waiter.push(template)
start_keeper if template.expires
while true
raise RequestCanceledError if template.canceled?
raise RequestExpiredError if template.expired?
entry = @bag.find(template)
if entry
port.push(entry.value) if port
@bag.delete(entry)
notify_event('take', entry.value)
return entry.value
end
template.wait
end
ensure
@take_waiter.delete(template)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q1806
|
Rinda.TupleSpace.read
|
train
|
def read(tuple, sec=nil)
template = WaitTemplateEntry.new(self, tuple, sec)
yield(template) if block_given?
synchronize do
entry = @bag.find(template)
return entry.value if entry
raise RequestExpiredError if template.expired?
begin
@read_waiter.push(template)
start_keeper if template.expires
template.wait
raise RequestCanceledError if template.canceled?
raise RequestExpiredError if template.expired?
return template.found
ensure
@read_waiter.delete(template)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q1807
|
Rinda.TupleSpace.read_all
|
train
|
def read_all(tuple)
template = WaitTemplateEntry.new(self, tuple, nil)
synchronize do
entry = @bag.find_all(template)
entry.collect do |e|
e.value
end
end
end
|
ruby
|
{
"resource": ""
}
|
q1808
|
Rinda.TupleSpace.notify
|
train
|
def notify(event, tuple, sec=nil)
template = NotifyTemplateEntry.new(self, event, tuple, sec)
synchronize do
@notify_waiter.push(template)
end
template
end
|
ruby
|
{
"resource": ""
}
|
q1809
|
Rinda.TupleSpace.keep_clean
|
train
|
def keep_clean
synchronize do
@read_waiter.delete_unless_alive.each do |e|
e.signal
end
@take_waiter.delete_unless_alive.each do |e|
e.signal
end
@notify_waiter.delete_unless_alive.each do |e|
e.notify(['close'])
end
@bag.delete_unless_alive.each do |e|
notify_event('delete', e.value)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q1810
|
Rinda.TupleSpace.notify_event
|
train
|
def notify_event(event, tuple)
ev = [event, tuple]
@notify_waiter.find_all_template(ev).each do |template|
template.notify(ev)
end
end
|
ruby
|
{
"resource": ""
}
|
q1811
|
ArubaDoubles.History.to_pretty
|
train
|
def to_pretty
to_a.each_with_index.map { |e,i| "%5d %s" % [i+1, e.shelljoin] }.join("\n")
end
|
ruby
|
{
"resource": ""
}
|
q1812
|
FogTracker.CollectionTracker.update
|
train
|
def update
new_collection = Array.new
fog_collection = @account_tracker.connection.send(@type) || Array.new
@log.info "Fetching #{fog_collection.count} #{@type} on #{@account_name}."
# Here's where most of the network overhead is actually incurred
fog_collection.each do |resource|
@log.debug "Fetching resource: #{resource.class} #{resource.identity}"
resource._fog_collection_tracker = self
new_collection << resource
#@log.debug "Got resource: #{resource.inspect}"
end
@log.info "Fetched #{new_collection.count} #{@type} on #{@account_name}."
@collection = new_collection
end
|
ruby
|
{
"resource": ""
}
|
q1813
|
FogTracker.AccountTracker.start
|
train
|
def start
if not running?
@log.debug "Starting tracking for account #{@name}..."
@timer = Thread.new do
begin
while true
update ; sleep @delay
end
rescue Exception => e
sleep @delay ; retry
end
end
else
@log.info "Already tracking account #{@name}"
end
end
|
ruby
|
{
"resource": ""
}
|
q1814
|
FogTracker.AccountTracker.update
|
train
|
def update
begin
@log.info "Polling account #{@name}..."
@collection_trackers.each {|tracker| tracker.update}
@preceeding_update_time = @most_recent_update
@most_recent_update = Time.now
@log.info "Polled account #{@name}"
@callback.call(all_resources) if @callback
rescue Exception => e
@log.error "Exception polling account #{name}: #{e.message}"
e.backtrace.each {|line| @log.debug line}
@error_proc.call(e) if @error_proc
raise e
end
end
|
ruby
|
{
"resource": ""
}
|
q1815
|
Fulmar.Shell.execute_quiet
|
train
|
def execute_quiet(command, error_message)
# Ladies and gentleman: More debug, please!
puts command if @debug
return_value = -1
Open3.popen3(environment, command) do |_stdin, stdout, stderr, wait_thread|
Thread.new do
stdout.each do |line|
@last_output << line.strip
puts line unless @quiet
end
end
Thread.new do
stderr.each do |line|
@last_error << line
puts line unless @quiet
end
end
_stdin.close
return_value = wait_thread.value
if @strict and return_value.exitstatus != 0
dump_error_message(command)
fail error_message
end
end
puts "Program exited with status #{return_value.exitstatus}." if @debug
return_value.exitstatus == 0
end
|
ruby
|
{
"resource": ""
}
|
q1816
|
Mangdown.Client.cbz
|
train
|
def cbz(dir)
Mangdown::CBZ.all(dir)
rescue StandardError => error
raise Mangdown::Error, "Failed to package #{dir}: #{error.message}"
end
|
ruby
|
{
"resource": ""
}
|
q1817
|
Trollop.Parser.each_arg
|
train
|
def each_arg(args)
remains = []
i = 0
until i >= args.length
return remains += args[i..-1] if @stop_words.member? args[i]
case args[i]
when /^--$/ # arg terminator
return remains += args[(i + 1)..-1]
when /^--(\S+?)=(.*)$/ # long argument with equals
num_params_taken = yield "--#{$1}", [$2]
if num_params_taken.nil?
remains << args[i]
if @stop_on_unknown
return remains += args[i + 1..-1]
end
end
i += 1
when /^--(\S+)$/ # long argument
params = collect_argument_parameters(args, i + 1)
num_params_taken = yield args[i], params
if num_params_taken.nil?
remains << args[i]
if @stop_on_unknown
return remains += args[i + 1..-1]
end
else
i += num_params_taken
end
i += 1
when /^-(\S+)$/ # one or more short arguments
short_remaining = ""
shortargs = $1.split(//)
shortargs.each_with_index do |a, j|
if j == (shortargs.length - 1)
params = collect_argument_parameters(args, i + 1)
num_params_taken = yield "-#{a}", params
unless num_params_taken
short_remaining << a
if @stop_on_unknown
remains << "-#{short_remaining}"
return remains += args[i + 1..-1]
end
else
i += num_params_taken
end
else
unless yield "-#{a}", []
short_remaining << a
if @stop_on_unknown
short_remaining += shortargs[j + 1..-1].join
remains << "-#{short_remaining}"
return remains += args[i + 1..-1]
end
end
end
end
unless short_remaining.empty?
remains << "-#{short_remaining}"
end
i += 1
else
if @stop_on_unknown
return remains += args[i..-1]
else
remains << args[i]
i += 1
end
end
end
remains
end
|
ruby
|
{
"resource": ""
}
|
q1818
|
DoesFacebook.ControllerExtensions.parse_signed_request
|
train
|
def parse_signed_request
Rails.logger.info " Facebook application \"#{fb_app.namespace}\" configuration in use for this request."
if request_parameter = request.params["signed_request"]
encoded_signature, encoded_data = request_parameter.split(".")
decoded_signature = base64_url_decode(encoded_signature)
decoded_data = base64_url_decode(encoded_data)
@fbparams = HashWithIndifferentAccess.new(JSON.parse(decoded_data))
Rails.logger.info " Facebook Parameters: #{fbparams.inspect}"
end
end
|
ruby
|
{
"resource": ""
}
|
q1819
|
Dis.Layer.store
|
train
|
def store(type, hash, file)
raise Dis::Errors::ReadOnlyError if readonly?
store!(type, hash, file)
end
|
ruby
|
{
"resource": ""
}
|
q1820
|
Dis.Layer.exists?
|
train
|
def exists?(type, hash)
if directory(type, hash) &&
directory(type, hash).files.head(key_component(type, hash))
true
else
false
end
end
|
ruby
|
{
"resource": ""
}
|
q1821
|
Dis.Layer.get
|
train
|
def get(type, hash)
dir = directory(type, hash)
return unless dir
dir.files.get(key_component(type, hash))
end
|
ruby
|
{
"resource": ""
}
|
q1822
|
Dis.Layer.delete
|
train
|
def delete(type, hash)
raise Dis::Errors::ReadOnlyError if readonly?
delete!(type, hash)
end
|
ruby
|
{
"resource": ""
}
|
q1823
|
DaemonRunner.Session.renew!
|
train
|
def renew!
return if renew?
@renew = Thread.new do
## Wakeup every TTL/2 seconds and renew the session
loop do
sleep ttl / 2
begin
logger.debug(" - Renewing Consul session #{id}")
Diplomat::Session.renew(id)
rescue Faraday::ResourceNotFound
logger.warn("Consul session #{id} has expired!")
init
rescue StandardError => e
## Keep the thread from exiting
logger.error(e)
end
end
end
self
end
|
ruby
|
{
"resource": ""
}
|
q1824
|
DaemonRunner.Session.verify_session
|
train
|
def verify_session(wait_time = 2)
logger.info(" - Wait until Consul session #{id} exists")
wait_time.times do
exists = session_exist?
raise CreateSessionError, 'Error creating session' unless exists
sleep 1
end
logger.info(" - Found Consul session #{id}")
rescue CreateSessionError
init
end
|
ruby
|
{
"resource": ""
}
|
q1825
|
DaemonRunner.Session.session_exist?
|
train
|
def session_exist?
sessions = Diplomat::Session.list
sessions.any? { |s| s['ID'] == id }
end
|
ruby
|
{
"resource": ""
}
|
q1826
|
RxFile.ArrayNode.long_out
|
train
|
def long_out io , level
indent = " " * level
@children.each_with_index do |child , i|
io.write "\n#{indent}" unless i == 0
io.write "- "
child.out(io , level + 1)
end
end
|
ruby
|
{
"resource": ""
}
|
q1827
|
Buckaruby.Gateway.issuers
|
train
|
def issuers(payment_method)
if payment_method != PaymentMethod::IDEAL && payment_method != PaymentMethod::IDEAL_PROCESSING
raise ArgumentError, "Invalid payment method, only iDEAL is supported."
end
Ideal::ISSUERS
end
|
ruby
|
{
"resource": ""
}
|
q1828
|
Buckaruby.Gateway.setup_transaction
|
train
|
def setup_transaction(options = {})
@logger.debug("[setup_transaction] options=#{options.inspect}")
validate_setup_transaction_params!(options)
normalize_account_iban!(options) if options[:payment_method] == PaymentMethod::SEPA_DIRECT_DEBIT
execute_request(:setup_transaction, options)
end
|
ruby
|
{
"resource": ""
}
|
q1829
|
Buckaruby.Gateway.refundable?
|
train
|
def refundable?(options = {})
@logger.debug("[refundable?] options=#{options.inspect}")
validate_required_params!(options, :transaction_id)
response = execute_request(:refund_info, options)
response.refundable?
end
|
ruby
|
{
"resource": ""
}
|
q1830
|
Buckaruby.Gateway.refund_transaction
|
train
|
def refund_transaction(options = {})
@logger.debug("[refund_transaction] options=#{options.inspect}")
validate_refund_transaction_params!(options)
response = execute_request(:refund_info, options)
unless response.refundable?
raise NonRefundableTransactionException, options[:transaction_id]
end
# Pick maximum refundable amount if amount is not supplied.
options[:amount] = response.maximum_amount unless options[:amount]
# Fill required parameters with data from refund info request.
options.merge!(
payment_method: response.payment_method,
invoicenumber: response.invoicenumber,
currency: response.currency
)
execute_request(:refund_transaction, options)
end
|
ruby
|
{
"resource": ""
}
|
q1831
|
Buckaruby.Gateway.cancellable?
|
train
|
def cancellable?(options = {})
@logger.debug("[cancellable?] options=#{options.inspect}")
validate_required_params!(options, :transaction_id)
response = execute_request(:status, options)
response.cancellable?
end
|
ruby
|
{
"resource": ""
}
|
q1832
|
Buckaruby.Gateway.cancel_transaction
|
train
|
def cancel_transaction(options = {})
@logger.debug("[cancel_transaction] options=#{options.inspect}")
validate_required_params!(options, :transaction_id)
response = execute_request(:status, options)
unless response.cancellable?
raise NonCancellableTransactionException, options[:transaction_id]
end
execute_request(:cancel, options)
end
|
ruby
|
{
"resource": ""
}
|
q1833
|
Buckaruby.Gateway.validate_required_params!
|
train
|
def validate_required_params!(params, *required)
required.flatten.each do |param|
if !params.key?(param) || params[param].to_s.empty?
raise ArgumentError, "Missing required parameter: #{param}."
end
end
end
|
ruby
|
{
"resource": ""
}
|
q1834
|
Buckaruby.Gateway.validate_setup_transaction_params!
|
train
|
def validate_setup_transaction_params!(options)
required_params = [:amount, :payment_method, :invoicenumber]
required_params << :return_url if options[:payment_method] != PaymentMethod::SEPA_DIRECT_DEBIT
case options[:payment_method]
when PaymentMethod::IDEAL, PaymentMethod::IDEAL_PROCESSING
required_params << :payment_issuer
when PaymentMethod::SEPA_DIRECT_DEBIT
required_params << [:account_iban, :account_name]
end
validate_required_params!(options, required_params)
validate_amount!(options)
valid_payment_methods = [
PaymentMethod::IDEAL, PaymentMethod::IDEAL_PROCESSING, PaymentMethod::VISA, PaymentMethod::MASTER_CARD, PaymentMethod::MAESTRO,
PaymentMethod::SEPA_DIRECT_DEBIT, PaymentMethod::PAYPAL, PaymentMethod::BANCONTACT_MISTER_CASH
]
validate_payment_method!(options, valid_payment_methods)
validate_payment_issuer!(options)
end
|
ruby
|
{
"resource": ""
}
|
q1835
|
Buckaruby.Gateway.validate_payment_issuer!
|
train
|
def validate_payment_issuer!(options)
if options[:payment_method] == PaymentMethod::IDEAL || options[:payment_method] == PaymentMethod::IDEAL_PROCESSING
unless Ideal::ISSUERS.include?(options[:payment_issuer])
raise ArgumentError, "Invalid payment issuer: #{options[:payment_issuer]}"
end
end
end
|
ruby
|
{
"resource": ""
}
|
q1836
|
Buckaruby.Gateway.validate_recurrent_transaction_params!
|
train
|
def validate_recurrent_transaction_params!(options)
required_params = [:amount, :payment_method, :invoicenumber, :transaction_id]
validate_required_params!(options, required_params)
validate_amount!(options)
valid_payment_methods = [
PaymentMethod::VISA, PaymentMethod::MASTER_CARD, PaymentMethod::MAESTRO,
PaymentMethod::SEPA_DIRECT_DEBIT, PaymentMethod::PAYPAL
]
validate_payment_method!(options, valid_payment_methods)
end
|
ruby
|
{
"resource": ""
}
|
q1837
|
Buckaruby.Gateway.execute_request
|
train
|
def execute_request(request_type, options)
request = build_request(request_type)
response = request.execute(options)
case request_type
when :setup_transaction
SetupTransactionResponse.new(response, config)
when :recurrent_transaction
RecurrentTransactionResponse.new(response, config)
when :refund_transaction
RefundTransactionResponse.new(response, config)
when :refund_info
RefundInfoResponse.new(response, config)
when :status
StatusResponse.new(response, config)
when :cancel
CancelResponse.new(response, config)
end
end
|
ruby
|
{
"resource": ""
}
|
q1838
|
Buckaruby.Gateway.build_request
|
train
|
def build_request(request_type)
case request_type
when :setup_transaction
SetupTransactionRequest.new(config)
when :recurrent_transaction
RecurrentTransactionRequest.new(config)
when :refund_transaction
RefundTransactionRequest.new(config)
when :refund_info
RefundInfoRequest.new(config)
when :status
StatusRequest.new(config)
when :cancel
CancelRequest.new(config)
end
end
|
ruby
|
{
"resource": ""
}
|
q1839
|
RxFile.Node.as_string
|
train
|
def as_string(level)
io = StringIO.new
out(io,level)
io.string
end
|
ruby
|
{
"resource": ""
}
|
q1840
|
RxFile.ObjectNode.add
|
train
|
def add k , v
raise "Key should be symbol not #{k}" unless k.is_a? Symbol
if( v.is_simple?)
@simple[k] = v
else
@complex[k] = v
end
end
|
ruby
|
{
"resource": ""
}
|
q1841
|
Blur.ScriptCache.save
|
train
|
def save
directory = File.dirname @path
unless File.directory? directory
Dir.mkdir directory
end
File.open @path, ?w do |file|
YAML.dump @hash, file
end
end
|
ruby
|
{
"resource": ""
}
|
q1842
|
Authmac.HmacChecker.params_sorted_by_key
|
train
|
def params_sorted_by_key(params)
case params
when Hash
params.map { |k, v| [k.to_s, params_sorted_by_key(v)] }
.sort_by { |k, v| k }
.to_h
when Array
params.map { |val| params_sorted_by_key(val) }
else
params.to_s
end
end
|
ruby
|
{
"resource": ""
}
|
q1843
|
Juici::Controllers.Trigger.rebuild!
|
train
|
def rebuild!
unless project = ::Juici::Project.where(name: params[:project]).first
not_found
end
unless build = ::Juici::Build.where(parent: project.name, _id: params[:id]).first
not_found
end
::Juici::Build.new_from(build).tap do |new_build|
new_build.save!
$build_queue << new_build
$build_queue.bump!
end
end
|
ruby
|
{
"resource": ""
}
|
q1844
|
ArubaDoubles.Double.run
|
train
|
def run(argv = ARGV)
history << [filename] + argv
output = @outputs[argv] || @default_output
puts output[:puts] if output[:puts]
warn output[:warn] if output[:warn]
exit output[:exit] if output[:exit]
end
|
ruby
|
{
"resource": ""
}
|
q1845
|
ArubaDoubles.Double.create
|
train
|
def create(&block)
register
self.instance_eval(&block) if block_given?
content = self.to_ruby
fullpath = File.join(self.class.bindir, filename)
#puts "creating double: #{fullpath} with content:\n#{content}" # debug
f = File.open(fullpath, 'w')
f.puts content
f.close
FileUtils.chmod(0755, File.join(self.class.bindir, filename))
self
end
|
ruby
|
{
"resource": ""
}
|
q1846
|
ArubaDoubles.Double.to_ruby
|
train
|
def to_ruby
ruby = ['#!/usr/bin/env ruby']
ruby << "$: << '#{File.expand_path('..', File.dirname(__FILE__))}'"
ruby << 'require "aruba-doubles"'
ruby << 'ArubaDoubles::Double.run do'
@outputs.each_pair { |argv,output| ruby << " on #{argv.inspect}, #{output.inspect}" }
ruby << 'end'
ruby.join("\n")
end
|
ruby
|
{
"resource": ""
}
|
q1847
|
ArubaDoubles.Double.delete
|
train
|
def delete
deregister
fullpath = File.join(self.class.bindir, filename)
FileUtils.rm(fullpath) if File.exists?(fullpath)
end
|
ruby
|
{
"resource": ""
}
|
q1848
|
Rackstash.FilterChain.[]=
|
train
|
def []=(index, filter)
raise TypeError, 'must provide a filter' unless filter.respond_to?(:call)
synchronize do
id = index_at(index)
unless id && ([email protected]).cover?(id)
raise ArgumentError, "Cannot insert at index #{index.inspect}"
end
@filters[id] = filter
end
end
|
ruby
|
{
"resource": ""
}
|
q1849
|
Rackstash.FilterChain.call
|
train
|
def call(event)
each do |filter|
result = filter.call(event)
return false if result == false
end
event
end
|
ruby
|
{
"resource": ""
}
|
q1850
|
Rackstash.FilterChain.insert_before
|
train
|
def insert_before(index, *filter_spec, &block)
filter = build_filter(filter_spec, &block)
synchronize do
id = index_at(index)
unless id && ([email protected]).cover?(id)
raise ArgumentError, "No such filter to insert before: #{index.inspect}"
end
@filters.insert(id, filter)
end
self
end
|
ruby
|
{
"resource": ""
}
|
q1851
|
Rackstash.FilterChain.build_filter
|
train
|
def build_filter(filter_spec, &block)
if filter_spec.empty?
return Rackstash::Filter.build(block) if block_given?
raise ArgumentError, 'Need to specify a filter'
else
Rackstash::Filter.build(*filter_spec, &block)
end
end
|
ruby
|
{
"resource": ""
}
|
q1852
|
DaemonRunner.Client.start!
|
train
|
def start!
wait
logger.warn 'Tasks list is empty' if tasks.empty?
tasks.each do |task|
run_task(task)
sleep post_task_sleep_time
end
scheduler.join
rescue SystemExit, Interrupt
logger.info 'Shutting down'
scheduler.shutdown
end
|
ruby
|
{
"resource": ""
}
|
q1853
|
Rackstash.ClassRegistry.fetch
|
train
|
def fetch(spec, default = UNDEFINED)
case spec
when Class
spec
when String, Symbol, ->(s) { s.respond_to?(:to_sym) }
@registry.fetch(spec.to_sym) do |key|
next yield(key) if block_given?
next default unless UNDEFINED.equal? default
raise KeyError, "No #{@object_type} was registered for #{spec.inspect}"
end
else
raise TypeError, "#{spec.inspect} can not be used to describe " \
"#{@object_type} classes"
end
end
|
ruby
|
{
"resource": ""
}
|
q1854
|
Rackstash.ClassRegistry.[]=
|
train
|
def []=(name, registered_class)
unless registered_class.is_a?(Class)
raise TypeError, 'Can only register class objects'
end
case name
when String, Symbol
@registry[name.to_sym] = registered_class
else
raise TypeError, "Can not use #{name.inspect} to register a #{@object_type} class"
end
registered_class
end
|
ruby
|
{
"resource": ""
}
|
q1855
|
Blur.Callbacks.emit
|
train
|
def emit name, *args
# Trigger callbacks in scripts before triggering events in the client.
EM.defer { notify_scripts name, *args }
matching_callbacks = callbacks[name]
return false unless matching_callbacks&.any?
EM.defer do
matching_callbacks.each { |callback| callback.call *args }
end
end
|
ruby
|
{
"resource": ""
}
|
q1856
|
VirtusModel.Base.export
|
train
|
def export(options = nil)
self.class.attributes.reduce({}) do |result, name|
value = attributes[name]
if self.class.association?(name, :many)
result[name] = export_values(value, options)
elsif self.class.association?(name, :one)
result[name] = export_value(value, options)
else
result[name] = value
end
result
end
end
|
ruby
|
{
"resource": ""
}
|
q1857
|
VirtusModel.Base.extract_attributes
|
train
|
def extract_attributes(model)
self.class.attributes.reduce({}) do |result, name|
if model.respond_to?(name)
result[name] = model.public_send(name)
elsif model.respond_to?(:[]) && model.respond_to?(:key?) && model.key?(name)
result[name] = model[name]
end
result
end
end
|
ruby
|
{
"resource": ""
}
|
q1858
|
VirtusModel.Base.validate_associations_many
|
train
|
def validate_associations_many
self.class.associations(:many).each do |name|
values = attributes[name] || []
values.each.with_index do |value, index|
import_errors("#{name}[#{index}]", value)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q1859
|
VirtusModel.Base.import_errors
|
train
|
def import_errors(name, model)
return unless model.respond_to?(:validate)
return if model.validate(validation_context)
model.errors.each do |field, error|
errors.add("#{name}[#{field}]", error)
end
end
|
ruby
|
{
"resource": ""
}
|
q1860
|
VirtusModel.Base.export_values
|
train
|
def export_values(values, options = nil)
return if values.nil?
values.map { |v| export_value(v, options) }
end
|
ruby
|
{
"resource": ""
}
|
q1861
|
VirtusModel.Base.export_value
|
train
|
def export_value(value, options = nil)
return if value.nil?
value.respond_to?(:export) ? value.export(options) : value
end
|
ruby
|
{
"resource": ""
}
|
q1862
|
DaemonRunner.Semaphore.contender_key
|
train
|
def contender_key(value = 'none')
if value.nil? || value.empty?
raise ArgumentError, 'Value cannot be empty or nil'
end
key = "#{prefix}/#{session.id}"
::DaemonRunner::RetryErrors.retry do
@contender_key = Diplomat::Lock.acquire(key, session.id, value)
end
@contender_key
end
|
ruby
|
{
"resource": ""
}
|
q1863
|
DaemonRunner.Semaphore.semaphore_state
|
train
|
def semaphore_state
options = { decode_values: true, recurse: true }
@state = Diplomat::Kv.get(prefix, options, :return)
decode_semaphore_state unless state.empty?
state
end
|
ruby
|
{
"resource": ""
}
|
q1864
|
DaemonRunner.Semaphore.write_lock
|
train
|
def write_lock
index = lock_modify_index.nil? ? 0 : lock_modify_index
value = generate_lockfile
return true if value == true
Diplomat::Kv.put(@lock, value, cas: index)
end
|
ruby
|
{
"resource": ""
}
|
q1865
|
DaemonRunner.Semaphore.renew?
|
train
|
def renew?
logger.debug("Watching Consul #{prefix} for changes")
options = { recurse: true }
changes = Diplomat::Kv.get(prefix, options, :wait, :wait)
logger.info("Changes on #{prefix} detected") if changes
changes
rescue StandardError => e
logger.error(e)
end
|
ruby
|
{
"resource": ""
}
|
q1866
|
DaemonRunner.Semaphore.decode_semaphore_state
|
train
|
def decode_semaphore_state
lock_key = state.find { |k| k['Key'] == @lock }
member_keys = state.delete_if { |k| k['Key'] == @lock }
member_keys.map! { |k| k['Key'] }
unless lock_key.nil?
@lock_modify_index = lock_key['ModifyIndex']
@lock_content = JSON.parse(lock_key['Value'])
end
@members = member_keys.map { |k| k.split('/')[-1] }
end
|
ruby
|
{
"resource": ""
}
|
q1867
|
DaemonRunner.Semaphore.prune_members
|
train
|
def prune_members
@holders = if lock_exists?
holders = lock_content['Holders']
return @holders = [] if holders.nil?
holders = holders.keys
holders & members
else
[]
end
end
|
ruby
|
{
"resource": ""
}
|
q1868
|
DaemonRunner.Semaphore.add_self_to_holders
|
train
|
def add_self_to_holders
@holders.uniq!
@reset = true if @holders.length == 0
return true if @holders.include? session.id
if @holders.length < limit
@holders << session.id
end
end
|
ruby
|
{
"resource": ""
}
|
q1869
|
DaemonRunner.Semaphore.format_holders
|
train
|
def format_holders
@holders.uniq!
@holders.sort!
holders = {}
logger.debug "Holders are: #{@holders.join(',')}"
@holders.map { |m| holders[m] = true }
@holders = holders
end
|
ruby
|
{
"resource": ""
}
|
q1870
|
DaemonRunner.Semaphore.generate_lockfile
|
train
|
def generate_lockfile
if lock_exists? && lock_content['Holders'] == @holders
logger.info 'Holders are unchanged, not updating'
return true
end
lockfile_format = {
'Limit' => limit,
'Holders' => @holders
}
JSON.generate(lockfile_format)
end
|
ruby
|
{
"resource": ""
}
|
q1871
|
Juici.BuildQueue.bump!
|
train
|
def bump!
return unless @started
update_children
candidate_children.each do |child|
next if @child_pids.any? do |pid|
get_build_by_pid(pid).parent == child.parent
end
# We're good to launch this build
Juici.dbgp "Starting another child process"
return child.tap do |cld|
if pid = cld.build!
Juici.dbgp "Started child: #{pid}"
@child_pids << pid
@builds_by_pid[pid] = cld
else
Juici.dbgp "Child #{cld} failed to start"
bump! # Ruby's recursion isn't great, but re{try,do} may as well be
# undefined behaviour here.
end
end
end
Juici.dbgp "I have quite enough to do"
end
|
ruby
|
{
"resource": ""
}
|
q1872
|
Blur.Network.got_message
|
train
|
def got_message message
@client.got_message self, message
rescue StandardError => exception
puts "#{exception.class}: #{exception.message}"
puts
puts '---'
puts exception.backtrace
end
|
ruby
|
{
"resource": ""
}
|
q1873
|
Blur.Network.disconnected!
|
train
|
def disconnected!
@channels.each { |_name, channel| channel.users.clear }
@channels.clear
@users.clear
@client.network_connection_closed self
end
|
ruby
|
{
"resource": ""
}
|
q1874
|
Blur.Network.transmit
|
train
|
def transmit name, *arguments
message = IRCParser::Message.new command: name.to_s, parameters: arguments
if @client.verbose
formatted_command = message.command.to_s.ljust 8, ' '
formatted_params = message.parameters.map(&:inspect).join ' '
log "#{'→' ^ :red} #{formatted_command} #{formatted_params}"
end
@connection.send_data "#{message}\r\n"
end
|
ruby
|
{
"resource": ""
}
|
q1875
|
SwitchBoard.RedisDataset.lock_id
|
train
|
def lock_id(locker_uid, id_to_lock, expire_in_sec = 5)
now = redis_time
@con.multi do
@con.zadd("#{LOCK_MAP_KEY}_z", (now + expire_in_sec), id_to_lock)
@con.hset("#{LOCK_MAP_KEY}_h", id_to_lock, locker_uid)
end
end
|
ruby
|
{
"resource": ""
}
|
q1876
|
Blur.Client.connect
|
train
|
def connect
networks = @networks.reject &:connected?
EventMachine.run do
load_scripts!
networks.each &:connect
EventMachine.error_handler do |exception|
log.error "#{exception.message ^ :bold} on line #{exception.line.to_s ^ :bold}"
puts exception.backtrace.join "\n"
end
end
end
|
ruby
|
{
"resource": ""
}
|
q1877
|
Blur.Client.quit
|
train
|
def quit signal = :SIGINT
@networks.each do |network|
network.transmit :QUIT, 'Got SIGINT?'
network.disconnect
end
EventMachine.stop
end
|
ruby
|
{
"resource": ""
}
|
q1878
|
Blur.Client.load_scripts!
|
train
|
def load_scripts!
scripts_dir = File.expand_path @config['blur']['scripts_dir']
script_file_paths = Dir.glob File.join scripts_dir, '*.rb'
# Sort the script file paths by file name so they load by alphabetical
# order.
#
# This will make it possible to create a script called '10_database.rb'
# which will be loaded before '20_settings.rb' and non-numeric prefixes
# will be loaded after that.
script_file_paths = script_file_paths.sort do |a, b|
File.basename(a) <=> File.basename(b)
end
script_file_paths.each { |script_path| load_script_file script_path }
initialize_superscripts
emit :scripts_loaded
end
|
ruby
|
{
"resource": ""
}
|
q1879
|
Blur.Client.load_script_file
|
train
|
def load_script_file file_path
load file_path, true
rescue Exception => exception
warn "The script `#{file_path}' failed to load"
warn "#{exception.class}: #{exception.message}"
warn ''
warn 'Backtrace:', '---', exception.backtrace
end
|
ruby
|
{
"resource": ""
}
|
q1880
|
Blur.Client.unload_scripts!
|
train
|
def unload_scripts!
@scripts.each do |name, script|
script.__send__ :unloaded if script.respond_to? :unloaded
end.clear
Blur.reset_scripts!
end
|
ruby
|
{
"resource": ""
}
|
q1881
|
Blur.Client.load_config!
|
train
|
def load_config!
config = YAML.load_file @config_path
if config.key? @environment
@config = config[@environment]
@config.deeper_merge! DEFAULT_CONFIG
emit :config_load
else
raise Error, "No configuration found for specified environment `#{@environment}'"
end
end
|
ruby
|
{
"resource": ""
}
|
q1882
|
Mangdown.Page.setup_path
|
train
|
def setup_path(dir = nil)
dir ||= chapter.path
dir = Tools.valid_path_name(dir)
name = self.name.tr('/', '')
file = Dir.entries(dir).find { |f| f[name] } if Dir.exist?(dir)
path = Tools.file_join(dir, file || name)
@path = Tools.relative_or_absolute_path(path)
end
|
ruby
|
{
"resource": ""
}
|
q1883
|
PageRight.TextHelper.is_text_in_page?
|
train
|
def is_text_in_page?(content, flag=true)
if flag
assert page.has_content?("#{content}"), "Error: #{content} not found page !"
else
assert !page.has_content?("#{content}"), "Error: #{content} found in page !"
end
end
|
ruby
|
{
"resource": ""
}
|
q1884
|
PageRight.TextHelper.is_text_in_section?
|
train
|
def is_text_in_section?(section, content, flag=true)
within("#{section}") do
if flag
assert page.has_content?("#{content}"), "Error: #{content} not found in #{section} !"
else
assert !page.has_content?("#{content}"), "Error: #{content} found in #{section} !"
end
end
end
|
ruby
|
{
"resource": ""
}
|
q1885
|
Juici.BuildEnvironment.load_json!
|
train
|
def load_json!(json)
return true if json == ""
loaded_json = JSON.load(json)
if loaded_json.is_a? Hash
env.merge!(loaded_json)
return true
end
false
rescue JSON::ParserError
return false
end
|
ruby
|
{
"resource": ""
}
|
q1886
|
Rackstash.Buffer.timestamp
|
train
|
def timestamp(time = nil)
@timestamp ||= begin
time ||= Time.now.utc.freeze
time = time.getutc.freeze unless time.utc? && time.frozen?
time
end
end
|
ruby
|
{
"resource": ""
}
|
q1887
|
Rackstash.Buffer.event
|
train
|
def event
event = fields.to_h
event[FIELD_TAGS] = tags.to_a
event[FIELD_MESSAGE] = messages
event[FIELD_TIMESTAMP] = timestamp
event
end
|
ruby
|
{
"resource": ""
}
|
q1888
|
RETS.HTTP.url_encode
|
train
|
def url_encode(str)
encoded_string = ""
str.each_char do |char|
case char
when "+"
encoded_string << "%2b"
when "="
encoded_string << "%3d"
when "?"
encoded_string << "%3f"
when "&"
encoded_string << "%26"
when "%"
encoded_string << "%25"
when ","
encoded_string << "%2C"
else
encoded_string << char
end
end
encoded_string
end
|
ruby
|
{
"resource": ""
}
|
q1889
|
RETS.HTTP.save_digest
|
train
|
def save_digest(header)
@request_count = 0
@digest = {}
header.split(",").each do |line|
k, v = line.strip.split("=", 2)
@digest[k] = (k != "algorithm" and k != "stale") && v[1..-2] || v
end
@digest_type = @digest["qop"] ? @digest["qop"].split(",") : []
end
|
ruby
|
{
"resource": ""
}
|
q1890
|
RETS.HTTP.create_digest
|
train
|
def create_digest(method, request_uri)
# http://en.wikipedia.org/wiki/Digest_access_authentication
first = Digest::MD5.hexdigest("#{@config[:username]}:#{@digest["realm"]}:#{@config[:password]}")
second = Digest::MD5.hexdigest("#{method}:#{request_uri}")
# Using the "newer" authentication QOP
if @digest_type.include?("auth")
cnonce = Digest::MD5.hexdigest("#{@headers["User-Agent"]}:#{@config[:password]}:#{@request_count}:#{@digest["nonce"]}")
hash = Digest::MD5.hexdigest("#{first}:#{@digest["nonce"]}:#{"%08X" % @request_count}:#{cnonce}:#{@digest["qop"]}:#{second}")
# Nothing specified, so default to the old one
elsif @digest_type.empty?
hash = Digest::MD5.hexdigest("#{first}:#{@digest["nonce"]}:#{second}")
else
raise RETS::HTTPError, "Cannot determine auth type for server (#{@digest_type.join(",")})"
end
http_digest = "Digest username=\"#{@config[:username]}\", "
http_digest << "realm=\"#{@digest["realm"]}\", "
http_digest << "nonce=\"#{@digest["nonce"]}\", "
http_digest << "uri=\"#{request_uri}\", "
http_digest << "algorithm=MD5, " unless @digest_type.empty?
http_digest << "response=\"#{hash}\", "
http_digest << "opaque=\"#{@digest["opaque"]}\""
unless @digest_type.empty?
http_digest << ", "
http_digest << "qop=\"#{@digest["qop"]}\", "
http_digest << "nc=#{"%08X" % @request_count}, "
http_digest << "cnonce=\"#{cnonce}\""
end
http_digest
end
|
ruby
|
{
"resource": ""
}
|
q1891
|
RETS.HTTP.get_rets_response
|
train
|
def get_rets_response(rets)
code, text = nil, nil
rets.attributes.each do |attr|
key = attr.first.downcase
if key == "replycode"
code = attr.last.value
elsif key == "replytext"
text = attr.last.value
end
end
# puts "replycode: #{code}"
return code, text
end
|
ruby
|
{
"resource": ""
}
|
q1892
|
TuneSpec.Instances.groups
|
train
|
def groups(name, opts = {}, *args, &block)
instance_handler(name, Groups, opts, *args, block)
end
|
ruby
|
{
"resource": ""
}
|
q1893
|
TuneSpec.Instances.steps
|
train
|
def steps(name, opts = {}, *args, &block)
opts[:page] && opts[:page] = pages(opts.fetch(:page))
instance_handler(name, Steps, opts, *args, block)
end
|
ruby
|
{
"resource": ""
}
|
q1894
|
TuneSpec.Instances.pages
|
train
|
def pages(name, opts = {}, *args, &block)
instance_handler(name, Page, opts, *args, block)
end
|
ruby
|
{
"resource": ""
}
|
q1895
|
Matchi.MatchersBase.to_s
|
train
|
def to_s
s = matcher_name
.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
.gsub(/([a-z\d])([A-Z])/, '\1_\2')
.downcase
defined?(@expected) ? [s, @expected.inspect].join(' ') : s
end
|
ruby
|
{
"resource": ""
}
|
q1896
|
FogTracker.Tracker.query
|
train
|
def query(query_string)
results = FogTracker::Query::QueryProcessor.new(
@trackers, :logger => @log
).execute(query_string)
(results.each {|r| yield r}) if block_given?
results
end
|
ruby
|
{
"resource": ""
}
|
q1897
|
FogTracker.Tracker.accounts=
|
train
|
def accounts=(new_accounts)
old_accounts = @accounts
@accounts = FogTracker.validate_accounts(new_accounts)
if (@accounts != old_accounts)
stop if (was_running = running?)
create_trackers
start if was_running
end
@accounts
end
|
ruby
|
{
"resource": ""
}
|
q1898
|
FogTracker.Tracker.create_trackers
|
train
|
def create_trackers
@trackers = Hash.new
@accounts.each do |name, account|
@log.debug "Setting up tracker for account #{name}"
@trackers[name] = AccountTracker.new(name, account, {
:delay => @delay, :error_callback => @error_proc, :logger => @log,
:callback => Proc.new do |resources|
# attach a QueryProcessor to all returned resources
qp = FogTracker::Query::QueryProcessor.new(@trackers, :logger => @log)
resources.each {|resource| resource._query_processor = qp}
# now relay the resources back to the client software
@callback.call(resources) if @callback
end
}
)
end
end
|
ruby
|
{
"resource": ""
}
|
q1899
|
Rackstash.Logger.<<
|
train
|
def <<(msg)
buffer.add_message Message.new(
msg,
time: Time.now.utc.freeze,
progname: @progname,
severity: UNKNOWN
)
msg
end
|
ruby
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.