_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q25800 | Ws2812.UnicornHAT.[]= | validation | def []=(x, y, color)
check_coords(x, y)
@pixels[x][y] = color
| ruby | {
"resource": ""
} |
q25801 | Ws2812.UnicornHAT.set | validation | def set(x, y, r, g, b)
check_coords(x, y)
| ruby | {
"resource": ""
} |
q25802 | Ws2812.UnicornHAT.rotation= | validation | def rotation=(val)
permissible = [0, 90, 180, 270]
fail ArgumentError, "invalid rotation, permissible: #{permissible.join(', ')}" unless | 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 | 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', | 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]
| 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 | 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!... | 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
| 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.
dep... | 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 | ruby | {
"resource": ""
} |
q25811 | Pupa.Processor.load_scraped_objects | validation | def load_scraped_objects
{}.tap do |objects|
@store.read_multi(@store.entries).each do |properties|
| 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
| 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 d... | 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|
| 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?
| 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]
| 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
| 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)
... | 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 = @p... | ruby | {
"resource": ""
} |
q25820 | Pupa.VoteEvent.add_group_result | validation | def add_group_result(result, group: nil)
data = {result: result}
if group
data[:group] = group
| 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
| ruby | {
"resource": ""
} |
q25822 | Danger.DangerJenkins.print_artifacts | validation | def print_artifacts
artifacts = build.artifacts
return if artifacts.empty?
content = "### Jenkins artifacts:\n\n"
| 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... | 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 = Call... | ruby | {
"resource": ""
} |
q25825 | Tmx.Objects.find | validation | def find(params)
params = { type: params } if params.is_a?(String)
found_objects = find_all do |object|
| 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 == | 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?
| 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
| 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, | ruby | {
"resource": ""
} |
q25830 | Linked.Listable.in_chain? | validation | def in_chain?(other)
return false unless | ruby | {
"resource": ""
} |
q25831 | Linked.Listable.before | validation | def before
return to_enum(__callee__) unless block_given?
return if chain_head?
item = prev
| ruby | {
"resource": ""
} |
q25832 | Linked.Listable.after | validation | def after
return to_enum(__callee__) unless block_given?
return if chain_tail?
item = self.next
| 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 | 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
unles... | 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, s... | 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
... | ruby | {
"resource": ""
} |
q25837 | Bitkassa.Config.debug= | validation | def debug=(mode)
@debug = mode
if mode
HTTPI.log = true
HTTPI.log_level = :debug
| 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
| ruby | {
"resource": ""
} |
q25839 | Linked.List.shift | validation | def shift
return nil if empty?
if list_head.last?
@_chain.tap { @_chain = nil }
else
| ruby | {
"resource": ""
} |
q25840 | GoldenRose.ResultsFilterer.compact_results | validation | def compact_results(items)
items.map do |subtest|
subtests = subtest[:subtests]
if subtests.size > | 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}",
| 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(',') })
| ruby | {
"resource": ""
} |
q25843 | CloudMade.TilesService.get_tile | validation | def get_tile(lat, lon, zoom, style_id = nil, tile_size = nil) | 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 | 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
| 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 = | 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
| ruby | {
"resource": ""
} |
q25848 | DuckPuncher.Registration.deregister | validation | def deregister(*targets)
targets.each &Ducks.list.method(:delete)
| ruby | {
"resource": ""
} |
q25849 | LogstashAuditor.LogstashAuditor.audit | validation | def audit(audit_data)
request = create_request(audit_data)
| 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
| 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"
| 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|
| 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_... | ruby | {
"resource": ""
} |
q25854 | Sequel.MigrationBuilder.alter_table_statement | validation | def alter_table_statement(table_name, operations)
add_line "alter_table #{table_name.inspect} do" | 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], | ruby | {
"resource": ""
} |
q25856 | SauceLabs.SauceBrowserFactory.watir_browser | validation | def watir_browser(browser,browser_options)
target,options = browser_caps(browser,browser_options)
| ruby | {
"resource": ""
} |
q25857 | SauceLabs.SauceBrowserFactory.selenium_driver | validation | def selenium_driver(browser,browser_options)
target,options | 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,platf... | 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)
| 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] | 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?)
| ruby | {
"resource": ""
} |
q25862 | SauceLabs.ParsedValues.extract_platform | validation | def extract_platform(value)
platform = value.to_s.split('|')[1] if value.to_s.include? | 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 | ruby | {
"resource": ""
} |
q25864 | StdNum.Helpers.extractNumber | validation | def extractNumber str
match = STDNUMPAT.match str
| ruby | {
"resource": ""
} |
q25865 | StdNum.Helpers.extract_multiple_numbers | validation | def extract_multiple_numbers(str)
return [] if str == '' || | 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
| 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 | 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_... | 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
| 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
| 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)
... | 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?(... | ruby | {
"resource": ""
} |
q25873 | Formula.FormulaFormBuilder.file? | validation | def file?(method)
@files ||= {}
@files[method] ||= begin
file = @object.send(method) if @object && @object.respond_to?(method)
| ruby | {
"resource": ""
} |
q25874 | Formula.FormulaFormBuilder.arrayorize | validation | def arrayorize(value)
case value
when nil then return []
| ruby | {
"resource": ""
} |
q25875 | YardTypes.KindType.check | validation | def check(obj)
if name == 'Boolean'
obj == true || obj == false
else
| ruby | {
"resource": ""
} |
q25876 | NetBooter.HttpConnection.toggle | validation | def toggle(outlet, status)
current_status = status(outlet) | 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 | 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)
| 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?
| 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]
| ruby | {
"resource": ""
} |
q25881 | MotionModel.ArrayFinderQuery.in | validation | def in(set)
@collection = @collection.collect do |item|
item | ruby | {
"resource": ""
} |
q25882 | MotionModel.ArrayFinderQuery.eq | validation | def eq(query_string, options = {:case_sensitive => false})
do_comparison(query_string, | ruby | {
"resource": ""
} |
q25883 | MotionModel.ArrayFinderQuery.gt | validation | def gt(query_string, options = {:case_sensitive => false})
do_comparison(query_string, options) do | ruby | {
"resource": ""
} |
q25884 | MotionModel.ArrayFinderQuery.lt | validation | def lt(query_string, options = {:case_sensitive => false})
do_comparison(query_string, options) do | ruby | {
"resource": ""
} |
q25885 | MotionModel.ArrayFinderQuery.gte | validation | def gte(query_string, options = {:case_sensitive => false})
do_comparison(query_string, | ruby | {
"resource": ""
} |
q25886 | MotionModel.ArrayFinderQuery.lte | validation | def lte(query_string, options = {:case_sensitive => false})
do_comparison(query_string, | ruby | {
"resource": ""
} |
q25887 | MotionModel.ArrayFinderQuery.ne | validation | def ne(query_string, options = {:case_sensitive => false})
do_comparison(query_string, | 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 = | ruby | {
"resource": ""
} |
q25889 | Stellar.Courses.mine | validation | def mine
page = @client.get_nokogiri '/atstellar'
class_links = page.css('a[href*="/S/course/"]').
map | ruby | {
"resource": ""
} |
q25890 | MotionModel.Validatable.error_messages_for | validation | def error_messages_for(field)
key = field.to_sym
| 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" : | 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 | 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 | 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}="
| 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
| 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 | ruby | {
"resource": ""
} |
q25897 | Stellar.Client.mech | validation | def mech(&block)
m = Mechanize.new do |m|
m.cert_store = OpenSSL::X509::Store.new
| ruby | {
"resource": ""
} |
q25898 | Stellar.Client.get_nokogiri | validation | def get_nokogiri(path)
uri = URI.join('https://stellar.mit.edu', | ruby | {
"resource": ""
} |
q25899 | MotionModel.InputHelpers.field_at | validation | def field_at(index)
data = self.class.instance_variable_get('@binding_data'.to_sym)
| ruby | {
"resource": ""
} |
Subsets and Splits
SQL Console for CoIR-Retrieval/CodeSearchNet-ccr-ruby-queries-corpus
Retrieves a large number of entries in the 'ruby' language, providing basic information but limited analytical value.