_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 !@description.nil? and !@description.empty?
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.