_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 66
10.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q25800
|
Ws2812.UnicornHAT.[]=
|
validation
|
def []=(x, y, color)
check_coords(x, y)
@pixels[x][y] = color
@hat[map_coords(x, y)] = color
end
|
ruby
|
{
"resource": ""
}
|
q25801
|
Ws2812.UnicornHAT.set
|
validation
|
def set(x, y, r, g, b)
check_coords(x, y)
self[x, y] = Color.new(r, g, b)
end
|
ruby
|
{
"resource": ""
}
|
q25802
|
Ws2812.UnicornHAT.rotation=
|
validation
|
def rotation=(val)
permissible = [0, 90, 180, 270]
fail ArgumentError, "invalid rotation, permissible: #{permissible.join(', ')}" unless permissible.include?(val % 360)
@rotation = val % 360
push_all_pixels
end
|
ruby
|
{
"resource": ""
}
|
q25803
|
Ws2812.UnicornHAT.check_coords
|
validation
|
def check_coords(x, y)
if 0 <= x && x < 8 && 0 <= y && y < 8
true
else
fail ArgumentError, "coord (#{x},#{y}) outside of permitted range ((0..7), (0..7))"
end
end
|
ruby
|
{
"resource": ""
}
|
q25804
|
Pupa.Model.validate!
|
validation
|
def validate!
if self.class.json_schema
self.class.validator.instance_variable_set('@errors', [])
self.class.validator.instance_variable_set('@data', stringify_keys(to_h(persist: true)))
self.class.validator.validate
true
end
end
|
ruby
|
{
"resource": ""
}
|
q25805
|
Pupa.Model.to_h
|
validation
|
def to_h(persist: false)
{}.tap do |hash|
(persist ? properties - foreign_objects : properties).each do |property|
value = self[property]
if value == false || value.present?
hash[property] = value
end
end
end
end
|
ruby
|
{
"resource": ""
}
|
q25806
|
Tmx.Map.export_to_file
|
validation
|
def export_to_file(filename, options={})
content_string = export_to_string(default_options(filename).merge(:filename => filename))
File.open(filename, "w") { |f| f.write(content_string) }
nil
end
|
ruby
|
{
"resource": ""
}
|
q25807
|
Tmx.Map.export_to_string
|
validation
|
def export_to_string(options = {})
hash = self.to_h
# Need to add back all non-tilelayers to hash["layers"]
image_layers = hash.delete(:image_layers)
object_groups = hash.delete(:object_groups)
hash[:layers] += image_layers
hash[:layers] += object_groups
hash[:layers].sort_by! { |l| l[:name] }
hash.delete(:contents)
object_groups.each do |object_layer|
object_layer["objects"].each do |object|
# If present, "shape" and "points" should be removed
object.delete("shape")
object.delete("points")
end
end
MultiJson.dump(hash)
end
|
ruby
|
{
"resource": ""
}
|
q25808
|
Pupa.Processor.dump_scraped_objects
|
validation
|
def dump_scraped_objects(task_name)
counts = Hash.new(0)
@store.pipelined do
send(task_name).each do |object|
counts[object._type] += 1
dump_scraped_object(object)
end
end
counts
end
|
ruby
|
{
"resource": ""
}
|
q25809
|
Pupa.Processor.import
|
validation
|
def import
@report[:import] = {}
objects = deduplicate(load_scraped_objects)
object_id_to_database_id = {}
if use_dependency_graph?(objects)
dependency_graph = build_dependency_graph(objects)
# Replace object IDs with database IDs in foreign keys and save objects.
dependency_graph.tsort.each do |id|
object = objects[id]
resolve_foreign_keys(object, object_id_to_database_id)
# The dependency graph strategy only works if there are no foreign objects.
database_id = import_object(object)
object_id_to_database_id[id] = database_id
object_id_to_database_id[database_id] = database_id
end
else
size = objects.size
# Should be O(n²). If there are foreign objects, we do not know all the
# edges in the graph, and therefore cannot build a dependency graph or
# derive any evaluation order.
#
# An exception is raised if a foreign object matches multiple documents
# in the database. However, if a matching object is not yet saved, this
# exception may not be raised.
loop do
progress_made = false
objects.delete_if do |id,object|
begin
resolve_foreign_keys(object, object_id_to_database_id)
resolve_foreign_objects(object, object_id_to_database_id)
progress_made = true
database_id = import_object(object)
object_id_to_database_id[id] = database_id
object_id_to_database_id[database_id] = database_id
rescue Pupa::Errors::MissingDatabaseIdError
false
end
end
break if objects.empty? || !progress_made
end
unless objects.empty?
raise Errors::UnprocessableEntity, "couldn't resolve #{objects.size}/#{size} objects:\n #{objects.values.map{|object| JSON.dump(object.foreign_properties)}.join("\n ")}"
end
end
# Ensure that fingerprints uniquely identified objects.
counts = {}
object_id_to_database_id.each do |object_id,database_id|
unless object_id == database_id
(counts[database_id] ||= []) << object_id
end
end
duplicates = counts.select do |_,object_ids|
object_ids.size > 1
end
unless duplicates.empty?
raise Errors::DuplicateDocumentError, "multiple objects written to same document:\n" + duplicates.map{|database_id,object_ids| " #{database_id} <- #{object_ids.join(' ')}"}.join("\n")
end
end
|
ruby
|
{
"resource": ""
}
|
q25810
|
Pupa.Processor.dump_scraped_object
|
validation
|
def dump_scraped_object(object)
type = object.class.to_s.demodulize.underscore
name = "#{type}_#{object._id.gsub(File::SEPARATOR, '_')}.json"
if @store.write_unless_exists(name, object.to_h)
info {"save #{type} #{object.to_s} as #{name}"}
else
raise Errors::DuplicateObjectIdError, "duplicate object ID: #{object._id} (was the same objected yielded twice?)"
end
if @validate
begin
object.validate!
rescue JSON::Schema::ValidationError => e
warn {e.message}
end
end
end
|
ruby
|
{
"resource": ""
}
|
q25811
|
Pupa.Processor.load_scraped_objects
|
validation
|
def load_scraped_objects
{}.tap do |objects|
@store.read_multi(@store.entries).each do |properties|
object = load_scraped_object(properties)
objects[object._id] = object
end
end
end
|
ruby
|
{
"resource": ""
}
|
q25812
|
Pupa.Processor.load_scraped_object
|
validation
|
def load_scraped_object(properties)
type = properties['_type'] || properties[:_type]
if type
type.camelize.constantize.new(properties)
else
raise Errors::MissingObjectTypeError, "missing _type: #{JSON.dump(properties)}"
end
end
|
ruby
|
{
"resource": ""
}
|
q25813
|
Pupa.Processor.deduplicate
|
validation
|
def deduplicate(objects)
losers_to_winners = build_losers_to_winners_map(objects)
# Remove all losers.
losers_to_winners.each_key do |key|
objects.delete(key)
end
# Swap the IDs of losers for the IDs of winners.
objects.each do |id,object|
object.foreign_keys.each do |property|
value = object[property]
if value && losers_to_winners.key?(value)
object[property] = losers_to_winners[value]
end
end
end
objects
end
|
ruby
|
{
"resource": ""
}
|
q25814
|
Pupa.Processor.build_losers_to_winners_map
|
validation
|
def build_losers_to_winners_map(objects)
inverse = {}
objects.each do |id,object|
(inverse[object.to_h.except(:_id)] ||= []) << id
end
{}.tap do |map|
inverse.values.each do |ids|
ids.drop(1).each do |id|
map[id] = ids[0]
end
end
end
end
|
ruby
|
{
"resource": ""
}
|
q25815
|
Pupa.Processor.use_dependency_graph?
|
validation
|
def use_dependency_graph?(objects)
objects.each do |id,object|
object.foreign_objects.each do |property|
if object[property].present?
return false
end
end
end
true
end
|
ruby
|
{
"resource": ""
}
|
q25816
|
Pupa.Processor.build_dependency_graph
|
validation
|
def build_dependency_graph(objects)
DependencyGraph.new.tap do |graph|
objects.each do |id,object|
graph[id] = [] # no duplicate IDs
object.foreign_keys.each do |property|
value = object[property]
if value
graph[id] << value
end
end
end
end
end
|
ruby
|
{
"resource": ""
}
|
q25817
|
Pupa.Processor.resolve_foreign_keys
|
validation
|
def resolve_foreign_keys(object, map)
object.foreign_keys.each do |property|
value = object[property]
if value
if map.key?(value)
object[property] = map[value]
else
raise Errors::MissingDatabaseIdError, "couldn't resolve foreign key: #{property} #{value}"
end
end
end
end
|
ruby
|
{
"resource": ""
}
|
q25818
|
Pupa.Processor.resolve_foreign_objects
|
validation
|
def resolve_foreign_objects(object, map)
object.foreign_objects.each do |property|
value = object[property]
if value.present?
foreign_object = ForeignObject.new(value)
resolve_foreign_keys(foreign_object, map)
document = connection.find(foreign_object.to_h)
if document
object["#{property}_id"] = document['_id']
else
raise Errors::MissingDatabaseIdError, "couldn't resolve foreign object: #{property} #{value}"
end
end
end
end
|
ruby
|
{
"resource": ""
}
|
q25819
|
Pupa.Runner.run
|
validation
|
def run(args, overrides = {})
rest = opts.parse!(args)
@options = OpenStruct.new(options.to_h.merge(overrides))
if options.actions.empty?
options.actions = %w(scrape import)
end
if options.tasks.empty?
options.tasks = @processor_class.tasks
end
processor = @processor_class.new(options.output_dir,
pipelined: options.pipelined,
cache_dir: options.cache_dir,
expires_in: options.expires_in,
value_max_bytes: options.value_max_bytes,
memcached_username: options.memcached_username,
memcached_password: options.memcached_password,
database_url: options.database_url,
validate: options.validate,
level: options.level,
faraday_options: options.faraday_options,
options: Hash[*rest])
options.actions.each do |action|
unless action == 'scrape' || processor.respond_to?(action)
abort %(`#{action}` is not a #{opts.program_name} action. See `#{opts.program_name} --help` for a list of available actions.)
end
end
if %w(DEBUG INFO).include?(options.level)
puts "processor: #{@processor_class}"
puts "actions: #{options.actions.join(', ')}"
puts "tasks: #{options.tasks.join(', ')}"
end
if options.level == 'DEBUG'
%w(output_dir pipelined cache_dir expires_in value_max_bytes memcached_username memcached_password database_url validate level).each do |option|
puts "#{option}: #{options[option]}"
end
unless rest.empty?
puts "options: #{rest.join(' ')}"
end
end
exit if options.dry_run
report = {
plan: {
processor: @processor_class,
options: Marshal.load(Marshal.dump(options)).to_h,
arguments: rest,
},
start: Time.now.utc,
}
if options.actions.delete('scrape')
processor.store.clear
report[:scrape] = {}
options.tasks.each do |task_name|
report[:scrape][task_name] = processor.dump_scraped_objects(task_name)
end
end
options.actions.each do |action|
processor.send(action)
if processor.report.key?(action.to_sym)
report.update(action.to_sym => processor.report[action.to_sym])
end
end
if %w(DEBUG INFO).include?(options.level)
report[:end] = Time.now.utc
report[:time] = report[:end] - report[:start]
puts JSON.dump(report)
end
end
|
ruby
|
{
"resource": ""
}
|
q25820
|
Pupa.VoteEvent.add_group_result
|
validation
|
def add_group_result(result, group: nil)
data = {result: result}
if group
data[:group] = group
end
if result.present?
@group_results << data
end
end
|
ruby
|
{
"resource": ""
}
|
q25821
|
Pupa.VoteEvent.add_count
|
validation
|
def add_count(option, value, group: nil)
data = {option: option, value: value}
if group
data[:group] = group
end
if option.present? && value.present?
@counts << data
end
end
|
ruby
|
{
"resource": ""
}
|
q25822
|
Danger.DangerJenkins.print_artifacts
|
validation
|
def print_artifacts
artifacts = build.artifacts
return if artifacts.empty?
content = "### Jenkins artifacts:\n\n"
content << "<img width='40' align='right' src='#{JENKINS_ICON}'></img>\n"
artifacts.each do |artifact|
content << "* #{artifact_link(artifact)}\n"
end
markdown content
end
|
ruby
|
{
"resource": ""
}
|
q25823
|
RPM.Transaction.delete
|
validation
|
def delete(pkg)
iterator = case pkg
when Package
pkg[:sigmd5] ? each_match(:sigmd5, pkg[:sigmd5]) : each_match(:label, pkg[:label])
when String
each_match(:label, pkg)
when Dependency
each_match(:label, pkg.name).set_iterator_version(pkg.version)
else
raise TypeError, 'illegal argument type'
end
iterator.each do |header|
ret = RPM::C.rpmtsAddEraseElement(@ptr, header.ptr, iterator.offset)
raise "Error while adding erase/#{pkg} to transaction" if ret != 0
end
end
|
ruby
|
{
"resource": ""
}
|
q25824
|
RPM.Transaction.commit
|
validation
|
def commit
flags = RPM::C::TransFlags[:none]
callback = proc do |hdr, type, amount, total, key_ptr, data_ignored|
key_id = key_ptr.address
key = @keys.include?(key_id) ? @keys[key_id] : nil
if block_given?
package = hdr.null? ? nil : Package.new(hdr)
data = CallbackData.new(type, key, package, amount, total)
yield(data)
else
RPM::C.rpmShowProgress(hdr, type, amount, total, key, data_ignored)
end
end
# We create a callback to pass to the C method and we
# call the user supplied callback from there
#
# The C callback expects you to return a file handle,
# We expect from the user to get a File, which we
# then convert to a file handle to return.
callback = proc do |hdr, type, amount, total, key_ptr, data_ignored|
key_id = key_ptr.address
key = @keys.include?(key_id) ? @keys[key_id] : nil
if block_given?
package = hdr.null? ? nil : Package.new(hdr)
data = CallbackData.new(type, key, package, amount, total)
ret = yield(data)
# For OPEN_FILE we need to do some type conversion
# for certain callback types we need to do some
case type
when :inst_open_file
# For :inst_open_file the user callback has to
# return the open file
unless ret.is_a?(::File)
raise TypeError, "illegal return value type #{ret.class}. Expected File."
end
fdt = RPM::C.fdDup(ret.to_i)
if fdt.null? || RPM::C.Ferror(fdt) != 0
raise "Can't use opened file #{data.key}: #{RPM::C.Fstrerror(fdt)}"
RPM::C.Fclose(fdt) unless fdt.nil?
else
fdt = RPM::C.fdLink(fdt)
@fdt = fdt
end
# return the (RPM type) file handle
fdt
when :inst_close_file
fdt = @fdt
RPM::C.Fclose(fdt)
@fdt = nil
else
ret
end
else
# No custom callback given, use the default to show progress
RPM::C.rpmShowProgress(hdr, type, amount, total, key, data_ignored)
end
end
rc = RPM::C.rpmtsSetNotifyCallback(@ptr, callback, nil)
raise "Can't set commit callback" if rc != 0
rc = RPM::C.rpmtsRun(@ptr, nil, :none)
raise "#{self}: #{RPM::C.rpmlogMessage}" if rc < 0
if rc > 0
ps = RPM::C.rpmtsProblems(@ptr)
psi = RPM::C.rpmpsInitIterator(ps)
while RPM::C.rpmpsNextIterator(psi) >= 0
problem = Problem.from_ptr(RPM::C.rpmpsGetProblem(psi))
STDERR.puts problem
end
RPM::C.rpmpsFree(ps)
end
end
|
ruby
|
{
"resource": ""
}
|
q25825
|
Tmx.Objects.find
|
validation
|
def find(params)
params = { type: params } if params.is_a?(String)
found_objects = find_all do |object|
params.any? {|key,value| object.send(key) == value.to_s }
end.compact
self.class.new found_objects
end
|
ruby
|
{
"resource": ""
}
|
q25826
|
Deacon.RandomGenerator.next_lfsr25
|
validation
|
def next_lfsr25(seed)
i = 1
i = (seed + 1) & MASK
raise ArgumentError, "Seed #{seed} out of bounds" if seed && i == 0
i = (seed + 1) & MASK while i == 0
i = (i >> 1) | ((i[0]^i[1]^i[2]^i[3]) << 0x18)
i = (i >> 1) | ((i[0]^i[1]^i[2]^i[3]) << 0x18) while i > MASK
i - 1
end
|
ruby
|
{
"resource": ""
}
|
q25827
|
Shebang.Command.parse
|
validation
|
def parse(argv = [])
@option_parser.parse!(argv)
options.each do |option|
if option.required? and !option.has_value?
Shebang.error("The -#{option.short} option is required")
end
end
return argv
end
|
ruby
|
{
"resource": ""
}
|
q25828
|
Shebang.Command.option
|
validation
|
def option(opt)
opt = opt.to_sym
options.each do |op|
if op.short === opt or op.long === opt
return op.value
end
end
end
|
ruby
|
{
"resource": ""
}
|
q25829
|
FCS.Client.method_missing
|
validation
|
def method_missing(method, *args, &block)
klass = class_for_api_command(method)
return klass.new(@socket).send(method, *args, &block) if klass
super(method, *args, &block)
end
|
ruby
|
{
"resource": ""
}
|
q25830
|
Linked.Listable.in_chain?
|
validation
|
def in_chain?(other)
return false unless other.is_a? Listable
chain_head.equal? other.chain_head
end
|
ruby
|
{
"resource": ""
}
|
q25831
|
Linked.Listable.before
|
validation
|
def before
return to_enum(__callee__) unless block_given?
return if chain_head?
item = prev
loop do
yield item
item = item.prev
end
end
|
ruby
|
{
"resource": ""
}
|
q25832
|
Linked.Listable.after
|
validation
|
def after
return to_enum(__callee__) unless block_given?
return if chain_tail?
item = self.next
loop do
yield item
item = item.next
end
end
|
ruby
|
{
"resource": ""
}
|
q25833
|
Bitkassa.PaymentResult.valid?
|
validation
|
def valid?
return false if raw_payload.nil? || raw_payload.empty?
return false if raw_authentication.nil? || raw_authentication.empty?
return false unless json_valid?
Authentication.valid?(raw_authentication, json_payload)
end
|
ruby
|
{
"resource": ""
}
|
q25834
|
IncrementalBackup.Task.run
|
validation
|
def run
# Validate - this will throw an exception if settings are not valid
validate_settings
# Run everything inside a lock, ensuring that only one instance of this
# task is running.
Lock.create(self) do
# Find the schedule to run
schedule = find_schedule
unless schedule
logger.info "No backup needed - exiting"
return
end
logger.info "Starting #{schedule} backup to #{settings.remote_server}"
# Paths and other options
timestamp = Time.now.strftime('backup_%Y-%m-%d-T%H-%M-%S')
current_path = File.join(settings.remote_path, 'current')
progress_path = File.join(settings.remote_path, 'incomplete')
complete_path = File.join(schedule_path(schedule), timestamp)
login = "#{settings.remote_user}@#{settings.remote_server}"
rsync_path = "#{login}:#{progress_path}"
# Make schedule folder
execute_ssh "mkdir --verbose --parents #{schedule_path schedule}"
# Rsync
Rsync.execute(logger, settings.local_path, rsync_path, {
exclude_file: settings.exclude_file,
link_dest: current_path,
max_upload_speed: settings.max_upload_speed,
max_download_speed: settings.max_download_speed
})
# shuffle backups around
logger.info "Do the backup shuffle"
execute_ssh [
"mv --verbose #{progress_path} #{complete_path}",
"rm --verbose --force #{current_path}",
"ln --verbose --symbolic #{complete_path} #{current_path}",
]
delete_old_backups schedule
logger.info "#{schedule} backup done"
end
rescue Exception => exception
logger.error exception.message
logger.error exception.backtrace
end
|
ruby
|
{
"resource": ""
}
|
q25835
|
IncrementalBackup.Task.execute_ssh
|
validation
|
def execute_ssh(commands)
commands = [commands] unless commands.is_a? Array
result = ""
Net::SSH.start settings.remote_server, settings.remote_user do |ssh|
commands.each do |command|
was_error = false
logger.info "ssh: #{command}"
ssh.exec! command do |channel, stream, data|
case stream
when :stdout
logger.info data
result += "#{data}\n" unless data.empty?
when :stderr
logger.error data
was_error = true
end
end
throw "Exception during ssh, look in log file" if was_error
end
end
result
end
|
ruby
|
{
"resource": ""
}
|
q25836
|
IncrementalBackup.Task.find_schedule
|
validation
|
def find_schedule
minutes = {
# If a cron job is run hourly it can be off by a couple of seconds
# from the last run. Set hourly to 58 minutes
hourly: 58,
daily: 24*60,
weekly: 7*24*60,
monthly: 30*24*60,
yearly: 365*24*60
}
now = DateTime.now
[:yearly, :monthly, :weekly, :daily, :hourly].each do |schedule|
next if backups_to_keep(schedule) <= 0
list = list_backup_dir schedule
date = list.map { |path| parse_backup_dir_name path, now.offset }.max
return schedule if !date || (now - date) * 24 * 60 >= minutes[schedule]
end
nil
end
|
ruby
|
{
"resource": ""
}
|
q25837
|
Bitkassa.Config.debug=
|
validation
|
def debug=(mode)
@debug = mode
if mode
HTTPI.log = true
HTTPI.log_level = :debug
else
HTTPI.log = false
end
end
|
ruby
|
{
"resource": ""
}
|
q25838
|
Shebang.Option.option_parser
|
validation
|
def option_parser
params = ["-#{@short}", "--#{@long}", nil, @options[:type]]
if [email protected]? and [email protected]?
params[2] = @description
end
# Set the correct format for the long/short option based on the type.
if ![TrueClass, FalseClass].include?(@options[:type])
params[1] += " #{@options[:key]}"
end
return params
end
|
ruby
|
{
"resource": ""
}
|
q25839
|
Linked.List.shift
|
validation
|
def shift
return nil if empty?
if list_head.last?
@_chain.tap { @_chain = nil }
else
old_head = list_head
@_chain = list_head.next
old_head.delete
end
end
|
ruby
|
{
"resource": ""
}
|
q25840
|
GoldenRose.ResultsFilterer.compact_results
|
validation
|
def compact_results(items)
items.map do |subtest|
subtests = subtest[:subtests]
if subtests.size > 1
subtests
elsif subtests.size == 1
compact_results(subtests)
end
end.flatten.compact
end
|
ruby
|
{
"resource": ""
}
|
q25841
|
BnetApi.WoW.pet_stats
|
validation
|
def pet_stats(species_id, options = {})
level = options[:level] || 1
breedId = options[:breedId] || 3
qualityId = options[:qualityId] || 1
BnetApi.make_request_with_params("/wow/pet/stats/#{species_id}",
{
level: level,
breedId: breedId,
qualityId: qualityId }
)
end
|
ruby
|
{
"resource": ""
}
|
q25842
|
BnetApi.WoW.realm_status
|
validation
|
def realm_status(*realms)
if realms.count > 0
BnetApi.make_request_with_params("/wow/realm/status", { realms: realms.join(',') })
else
BnetApi.make_request("/wow/realm/status")
end
end
|
ruby
|
{
"resource": ""
}
|
q25843
|
CloudMade.TilesService.get_tile
|
validation
|
def get_tile(lat, lon, zoom, style_id = nil, tile_size = nil)
get_xy_tile(xtile(lon, zoom), ytile(lat, zoom), zoom, style_id, tile_size)
end
|
ruby
|
{
"resource": ""
}
|
q25844
|
CloudMade.TilesService.get_xy_tile
|
validation
|
def get_xy_tile(xtile, ytile, zoom, style_id = nil, tile_size = nil)
style_id = self.default_style_id if style_id == nil
tile_size = self.default_tile_size if tile_size == nil
connect "/#{style_id}/#{tile_size}/#{zoom}/#{xtile}/#{ytile}.png"
end
|
ruby
|
{
"resource": ""
}
|
q25845
|
Linked.ListEnumerable.each_item
|
validation
|
def each_item
return to_enum(__method__) { count } unless block_given?
return if empty?
item = list_head
loop do
yield item
item = item.next
end
end
|
ruby
|
{
"resource": ""
}
|
q25846
|
Linked.ListEnumerable.reverse_each_item
|
validation
|
def reverse_each_item
return to_enum(__method__) { count } unless block_given?
return if empty?
item = list_tail
loop do
yield item
item = item.prev
end
end
|
ruby
|
{
"resource": ""
}
|
q25847
|
DuckPuncher.Registration.register
|
validation
|
def register(target, *mods, &block)
options = mods.last.is_a?(Hash) ? mods.pop : {}
mods << Module.new(&block) if block
target = DuckPuncher.lookup_constant target
Ducks.list[target] = Set.new [] unless Ducks.list.key?(target)
mods = Array(mods).each do |mod|
duck = UniqueDuck.new Duck.new(target, mod, options)
Ducks.list[target] << duck
end
[target, *mods]
end
|
ruby
|
{
"resource": ""
}
|
q25848
|
DuckPuncher.Registration.deregister
|
validation
|
def deregister(*targets)
targets.each &Ducks.list.method(:delete)
targets.each &decorators.method(:delete)
end
|
ruby
|
{
"resource": ""
}
|
q25849
|
LogstashAuditor.LogstashAuditor.audit
|
validation
|
def audit(audit_data)
request = create_request(audit_data)
http = create_http_transport
send_request_to_server(http, request)
end
|
ruby
|
{
"resource": ""
}
|
q25850
|
Sequel.MigrationBuilder.generate_migration
|
validation
|
def generate_migration(tables)
return if tables.empty? && @db_tables.empty?
result.clear
add_line "Sequel.migration do"
indent do
generate_migration_body(tables)
end
add_line "end\n"
result.join("\n")
end
|
ruby
|
{
"resource": ""
}
|
q25851
|
Sequel.MigrationBuilder.generate_migration_body
|
validation
|
def generate_migration_body(tables)
current_tables, new_tables = table_names(tables).partition do |table_name|
@db_table_names.include?(table_name)
end
add_line "change do"
create_new_tables(new_tables, tables)
alter_tables(current_tables, tables)
add_line "end"
end
|
ruby
|
{
"resource": ""
}
|
q25852
|
Sequel.MigrationBuilder.create_new_tables
|
validation
|
def create_new_tables(new_table_names, tables)
each_table(new_table_names, tables) do |table_name, table, last_table|
create_table_statement table_name, table
add_blank_line unless last_table
end
end
|
ruby
|
{
"resource": ""
}
|
q25853
|
Sequel.MigrationBuilder.alter_tables
|
validation
|
def alter_tables(current_table_names, tables)
each_table(current_table_names, tables) do |table_name, table, last_table|
hsh = table.dup
hsh[:columns] = hsh[:columns].map {|c| Schema::DbColumn.build_from_hash(c) }
operations = Schema::AlterTableOperations.
build(@db_tables[table_name], hsh, :immutable_columns => @immutable_columns)
unless operations.empty?
all_operations = if @separate_alter_table_statements
operations.map {|o| [o] }
else
[operations]
end
all_operations.each_with_index do |o, i|
alter_table_statement table_name, o
add_blank_line unless last_table && i + 1 == all_operations.size
end
end
end
end
|
ruby
|
{
"resource": ""
}
|
q25854
|
Sequel.MigrationBuilder.alter_table_statement
|
validation
|
def alter_table_statement(table_name, operations)
add_line "alter_table #{table_name.inspect} do"
indent do
operations.compact.each {|op| add_line op }
end
add_line "end"
end
|
ruby
|
{
"resource": ""
}
|
q25855
|
Sequel.MigrationBuilder.create_table_statement
|
validation
|
def create_table_statement(table_name, table)
normalize_primary_key(table)
add_line "create_table #{table_name.inspect}#{pretty_hash(table[:table_options])} do"
indent do
output_columns(table[:columns], table[:primary_key])
output_indexes(table[:indexes])
output_primary_key(table)
end
add_line "end"
end
|
ruby
|
{
"resource": ""
}
|
q25856
|
SauceLabs.SauceBrowserFactory.watir_browser
|
validation
|
def watir_browser(browser,browser_options)
target,options = browser_caps(browser,browser_options)
create_watir_browser(target,options)
end
|
ruby
|
{
"resource": ""
}
|
q25857
|
SauceLabs.SauceBrowserFactory.selenium_driver
|
validation
|
def selenium_driver(browser,browser_options)
target,options = browser_caps(browser,browser_options)
create_selenium_driver(target,options)
end
|
ruby
|
{
"resource": ""
}
|
q25858
|
SauceLabs.SauceBrowserFactory.browser_caps
|
validation
|
def browser_caps(browser,browser_options)
target = (browser.to_sym if ENV['BROWSER'].nil? or ENV['browser'].empty?) || (ENV['BROWSER'].to_sym)
browser,version,platform,device = extract_values_from(target)
options = {}
options.merge! browser_options
caps = capabilities(browser,version,platform,device)
options[:url] = url if url
if options.include? :url
browser = :remote
options[:desired_capabilities] = caps
end
options[:http_client] = http_client if persistent_http or options.delete(:persistent_http)
return browser,options
end
|
ruby
|
{
"resource": ""
}
|
q25859
|
SauceLabs.ParsedValues.extract_values_from
|
validation
|
def extract_values_from(browser_string)
browser = extract_browser(browser_string).to_sym
version = extract_version(browser_string)
platform = extract_platform(browser_string)
device = extract_device(browser_string)
return browser,version,platform,device
end
|
ruby
|
{
"resource": ""
}
|
q25860
|
SauceLabs.ParsedValues.extract_browser
|
validation
|
def extract_browser(value)
browser = value.to_s.split(/\d+/)[0]
browser = browser.to_s.split('|')[0] if browser.to_s.include? '|'
browser
end
|
ruby
|
{
"resource": ""
}
|
q25861
|
SauceLabs.ParsedValues.extract_version
|
validation
|
def extract_version(value)
value = value.to_s.split('|')[0] if value.to_s.include? '|'
regexp_to_match = /\d{1,}/
if (not regexp_to_match.match(value).nil?)
version = regexp_to_match.match(value)[0]
else
version = ''
end
version
end
|
ruby
|
{
"resource": ""
}
|
q25862
|
SauceLabs.ParsedValues.extract_platform
|
validation
|
def extract_platform(value)
platform = value.to_s.split('|')[1] if value.to_s.include? '|'
sauce_platforms
@sauce_platforms[platform] if not platform.nil?
end
|
ruby
|
{
"resource": ""
}
|
q25863
|
SauceLabs.ParsedValues.extract_device
|
validation
|
def extract_device(value)
device = value.to_s.split('|')[2] if value.to_s.include? '|'
sauce_devices
@sauce_devices[device] if not device.nil?
end
|
ruby
|
{
"resource": ""
}
|
q25864
|
StdNum.Helpers.extractNumber
|
validation
|
def extractNumber str
match = STDNUMPAT.match str
return nil unless match
return (match[1].gsub(/\-/, '')).upcase
end
|
ruby
|
{
"resource": ""
}
|
q25865
|
StdNum.Helpers.extract_multiple_numbers
|
validation
|
def extract_multiple_numbers(str)
return [] if str == '' || str.nil?
str.scan(STDNUMPAT_MULTIPLE).flatten.map{ |i| i.gsub(/\-/, '').upcase }
end
|
ruby
|
{
"resource": ""
}
|
q25866
|
Mongoid::Acts::NestedSet.Update.set_default_left_and_right
|
validation
|
def set_default_left_and_right
maxright = nested_set_scope.remove_order_by.max(right_field_name) || 0
self[left_field_name] = maxright + 1
self[right_field_name] = maxright + 2
self[:depth] = 0
end
|
ruby
|
{
"resource": ""
}
|
q25867
|
Mongoid::Acts::NestedSet.Update.update_self_and_descendants_depth
|
validation
|
def update_self_and_descendants_depth
if depth?
scope_class.each_with_level(self_and_descendants) do |node, level|
node.with(:safe => true).set(:depth, level) unless node.depth == level
end
self.reload
end
self
end
|
ruby
|
{
"resource": ""
}
|
q25868
|
Mongoid::Acts::NestedSet.Update.destroy_descendants
|
validation
|
def destroy_descendants
return if right.nil? || left.nil? || skip_before_destroy
if acts_as_nested_set_options[:dependent] == :destroy
descendants.each do |model|
model.skip_before_destroy = true
model.destroy
end
else
c = nested_set_scope.where(left_field_name.to_sym.gt => left, right_field_name.to_sym.lt => right)
scope_class.where(c.selector).delete_all
end
# update lefts and rights for remaining nodes
diff = right - left + 1
scope_class.with(:safe => true).where(
nested_set_scope.where(left_field_name.to_sym.gt => right).selector
).inc(left_field_name, -diff)
scope_class.with(:safe => true).where(
nested_set_scope.where(right_field_name.to_sym.gt => right).selector
).inc(right_field_name, -diff)
# Don't allow multiple calls to destroy to corrupt the set
self.skip_before_destroy = true
end
|
ruby
|
{
"resource": ""
}
|
q25869
|
NLP.TextStatistics.add
|
validation
|
def add(word,categories)
categories.each do |category|
@cwords[category] = [] if @cwords[category].nil?
@cwords[category].push word
@scores[category] += 1
end
@words.push word
@word_count += 1
end
|
ruby
|
{
"resource": ""
}
|
q25870
|
Formula.FormulaFormBuilder.button
|
validation
|
def button(value = nil, options = {})
options[:button] ||= {}
options[:container] ||= {}
options[:container][:class] = arrayorize(options[:container][:class]) << ::Formula.block_class
@template.content_tag(::Formula.block_tag, options[:container]) do
submit value, options[:button]
end
end
|
ruby
|
{
"resource": ""
}
|
q25871
|
Formula.FormulaFormBuilder.block
|
validation
|
def block(method = nil, options = {}, &block)
options[:error] ||= error(method) if method
components = "".html_safe
if method
components << self.label(method, options[:label]) if options[:label] or options[:label].nil? and method
end
components << @template.capture(&block)
options[:container] ||= {}
options[:container][:class] = arrayorize(options[:container][:class]) << ::Formula.block_class << method
options[:container][:class] << ::Formula.block_error_class if ::Formula.block_error_class.present? and error?(method)
components << @template.content_tag(::Formula.hint_tag , options[:hint ], :class => ::Formula.hint_class ) if options[:hint ]
components << @template.content_tag(::Formula.error_tag, options[:error], :class => ::Formula.error_class) if options[:error]
@template.content_tag(::Formula.block_tag, options[:container]) do
components
end
end
|
ruby
|
{
"resource": ""
}
|
q25872
|
Formula.FormulaFormBuilder.input
|
validation
|
def input(method, options = {})
options[:as] ||= as(method)
options[:input] ||= {}
return hidden_field method, options[:input] if options[:as] == :hidden
klass = [::Formula.input_class, options[:as]]
klass << ::Formula.input_error_class if ::Formula.input_error_class.present? and error?(method)
self.block(method, options) do
@template.content_tag(::Formula.input_tag, :class => klass) do
case options[:as]
when :text then text_area method, ::Formula.area_options.merge(options[:input] || {})
when :file then file_field method, ::Formula.file_options.merge(options[:input] || {})
when :string then text_field method, ::Formula.field_options.merge(options[:input] || {})
when :password then password_field method, ::Formula.field_options.merge(options[:input] || {})
when :url then url_field method, ::Formula.field_options.merge(options[:input] || {})
when :email then email_field method, ::Formula.field_options.merge(options[:input] || {})
when :phone then phone_field method, ::Formula.field_options.merge(options[:input] || {})
when :number then number_field method, ::Formula.field_options.merge(options[:input] || {})
when :boolean then check_box method, ::Formula.box_options.merge(options[:input] || {})
when :country then country_select method, ::Formula.select_options.merge(options[:input] || {})
when :date then date_select method, ::Formula.select_options.merge(options[:input] || {}), options[:input].delete(:html) || {}
when :time then time_select method, ::Formula.select_options.merge(options[:input] || {}), options[:input].delete(:html) || {}
when :datetime then datetime_select method, ::Formula.select_options.merge(options[:input] || {}), options[:input].delete(:html) || {}
when :select then select method, options[:choices], ::Formula.select_options.merge(options[:input] || {}), options[:input].delete(:html) || {}
end
end
end
end
|
ruby
|
{
"resource": ""
}
|
q25873
|
Formula.FormulaFormBuilder.file?
|
validation
|
def file?(method)
@files ||= {}
@files[method] ||= begin
file = @object.send(method) if @object && @object.respond_to?(method)
file && ::Formula.file.any? { |method| file.respond_to?(method) }
end
end
|
ruby
|
{
"resource": ""
}
|
q25874
|
Formula.FormulaFormBuilder.arrayorize
|
validation
|
def arrayorize(value)
case value
when nil then return []
when String then value.to_s.split
when Symbol then value.to_s.split
else value
end
end
|
ruby
|
{
"resource": ""
}
|
q25875
|
YardTypes.KindType.check
|
validation
|
def check(obj)
if name == 'Boolean'
obj == true || obj == false
else
obj.kind_of? constant
end
end
|
ruby
|
{
"resource": ""
}
|
q25876
|
NetBooter.HttpConnection.toggle
|
validation
|
def toggle(outlet, status)
current_status = status(outlet)
toggle_relay(outlet) if current_status != status
status
end
|
ruby
|
{
"resource": ""
}
|
q25877
|
NetBooter.HttpConnection.get_request
|
validation
|
def get_request(path)
resp = nil
begin
Timeout::timeout(5) do
resp = do_http_request(path)
end
rescue => e
raise NetBooter::Error.new("Error connecting to relay: #{e.message}")
end
resp
end
|
ruby
|
{
"resource": ""
}
|
q25878
|
MotionModel.ArrayModelAdapter.encodeWithCoder
|
validation
|
def encodeWithCoder(coder)
columns.each do |attr|
# Serialize attributes except the proxy has_many and belongs_to ones.
unless [:belongs_to, :has_many, :has_one].include? column(attr).type
value = self.send(attr)
unless value.nil?
coder.encodeObject(value, forKey: attr.to_s)
end
end
end
end
|
ruby
|
{
"resource": ""
}
|
q25879
|
MotionModel.ArrayFinderQuery.order
|
validation
|
def order(field = nil, &block)
if block_given?
@collection = @collection.sort{|o1, o2| yield(o1, o2)}
else
raise ArgumentError.new('you must supply a field name to sort unless you supply a block.') if field.nil?
@collection = @collection.sort{|o1, o2| o1.send(field) <=> o2.send(field)}
end
self
end
|
ruby
|
{
"resource": ""
}
|
q25880
|
MotionModel.ArrayFinderQuery.contain
|
validation
|
def contain(query_string, options = {:case_sensitive => false})
do_comparison(query_string) do |comparator, item|
if options[:case_sensitive]
item =~ Regexp.new(comparator, Regexp::MULTILINE)
else
item =~ Regexp.new(comparator, Regexp::IGNORECASE | Regexp::MULTILINE)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q25881
|
MotionModel.ArrayFinderQuery.in
|
validation
|
def in(set)
@collection = @collection.collect do |item|
item if set.include?(item.send(@field_name.to_sym))
end.compact
end
|
ruby
|
{
"resource": ""
}
|
q25882
|
MotionModel.ArrayFinderQuery.eq
|
validation
|
def eq(query_string, options = {:case_sensitive => false})
do_comparison(query_string, options) do |comparator, item|
comparator == item
end
end
|
ruby
|
{
"resource": ""
}
|
q25883
|
MotionModel.ArrayFinderQuery.gt
|
validation
|
def gt(query_string, options = {:case_sensitive => false})
do_comparison(query_string, options) do |comparator, item|
comparator < item
end
end
|
ruby
|
{
"resource": ""
}
|
q25884
|
MotionModel.ArrayFinderQuery.lt
|
validation
|
def lt(query_string, options = {:case_sensitive => false})
do_comparison(query_string, options) do |comparator, item|
comparator > item
end
end
|
ruby
|
{
"resource": ""
}
|
q25885
|
MotionModel.ArrayFinderQuery.gte
|
validation
|
def gte(query_string, options = {:case_sensitive => false})
do_comparison(query_string, options) do |comparator, item|
comparator <= item
end
end
|
ruby
|
{
"resource": ""
}
|
q25886
|
MotionModel.ArrayFinderQuery.lte
|
validation
|
def lte(query_string, options = {:case_sensitive => false})
do_comparison(query_string, options) do |comparator, item|
comparator >= item
end
end
|
ruby
|
{
"resource": ""
}
|
q25887
|
MotionModel.ArrayFinderQuery.ne
|
validation
|
def ne(query_string, options = {:case_sensitive => false})
do_comparison(query_string, options) do |comparator, item|
comparator != item
end
end
|
ruby
|
{
"resource": ""
}
|
q25888
|
Music.Chord.inversion
|
validation
|
def inversion(amount)
fail ArgumentError, 'Inversion amount must be greater than or equal to 1' if amount < 1
fail ArgumentError, 'Not enough notes in chord for inversion' if amount >= @notes.size
note_array = @notes.to_a.sort
notes = (0...amount).collect { note_array.shift.adjust_by_semitones(12) }
Chord.new(notes + note_array)
end
|
ruby
|
{
"resource": ""
}
|
q25889
|
Stellar.Courses.mine
|
validation
|
def mine
page = @client.get_nokogiri '/atstellar'
class_links = page.css('a[href*="/S/course/"]').
map { |link| Stellar::Course.from_link link, @client }.reject(&:nil?)
end
|
ruby
|
{
"resource": ""
}
|
q25890
|
MotionModel.Validatable.error_messages_for
|
validation
|
def error_messages_for(field)
key = field.to_sym
error_messages.select{|message| message.has_key?(key)}.map{|message| message[key]}
end
|
ruby
|
{
"resource": ""
}
|
q25891
|
MotionModel.Validatable.validate_presence
|
validation
|
def validate_presence(field, value, setting)
if(value.is_a?(Numeric))
return true
elsif value.is_a?(String) || value.nil?
result = value.nil? || ((value.length == 0) == setting)
additional_message = setting ? "non-empty" : "non-empty"
add_message(field, "incorrect value supplied for #{field.to_s} -- should be #{additional_message}.") if result
return !result
end
return false
end
|
ruby
|
{
"resource": ""
}
|
q25892
|
MotionModel.Validatable.validate_length
|
validation
|
def validate_length(field, value, setting)
if value.is_a?(String) || value.nil?
result = value.nil? || (value.length < setting.first || value.length > setting.last)
add_message(field, "incorrect value supplied for #{field.to_s} -- should be between #{setting.first} and #{setting.last} characters long.") if result
return !result
end
return false
end
|
ruby
|
{
"resource": ""
}
|
q25893
|
MotionModel.Validatable.validate_format
|
validation
|
def validate_format(field, value, setting)
result = value.nil? || setting.match(value).nil?
add_message(field, "#{field.to_s} does not appear to be in the proper format.") if result
return !result
end
|
ruby
|
{
"resource": ""
}
|
q25894
|
MotionModel.Model.set_auto_date_field
|
validation
|
def set_auto_date_field(field_name)
unless self.class.protect_remote_timestamps?
method = "#{field_name}="
self.send(method, Time.now) if self.respond_to?(method)
end
end
|
ruby
|
{
"resource": ""
}
|
q25895
|
MotionModel.Model.set_belongs_to_attr
|
validation
|
def set_belongs_to_attr(col, owner, options = {})
_col = column(col)
unless belongs_to_synced?(_col, owner)
_set_attr(_col.name, owner)
rebuild_relation(_col, owner, set_inverse: options[:set_inverse])
if _col.polymorphic
set_polymorphic_attr(_col.name, owner)
else
_set_attr(_col.foreign_key, owner ? owner.id : nil)
end
end
owner
end
|
ruby
|
{
"resource": ""
}
|
q25896
|
Stellar.Homework.submissions
|
validation
|
def submissions
page = @client.get_nokogiri @url
@submissions ||= page.css('.gradeTable tbody tr').map { |tr|
begin
Stellar::Homework::Submission.new tr, self
rescue ArgumentError
nil
end
}.reject(&:nil?)
end
|
ruby
|
{
"resource": ""
}
|
q25897
|
Stellar.Client.mech
|
validation
|
def mech(&block)
m = Mechanize.new do |m|
m.cert_store = OpenSSL::X509::Store.new
m.cert_store.add_file mitca_path
m.user_agent_alias = 'Linux Firefox'
yield m if block
m
end
m
end
|
ruby
|
{
"resource": ""
}
|
q25898
|
Stellar.Client.get_nokogiri
|
validation
|
def get_nokogiri(path)
uri = URI.join('https://stellar.mit.edu', path)
raw_html = @mech.get_file uri
Nokogiri.HTML raw_html, uri.to_s
end
|
ruby
|
{
"resource": ""
}
|
q25899
|
MotionModel.InputHelpers.field_at
|
validation
|
def field_at(index)
data = self.class.instance_variable_get('@binding_data'.to_sym)
data[index].tag = index + 1
data[index]
end
|
ruby
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.