_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 30
4.3k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q27300 | Woodhouse::Worker.ClassMethods.method_missing | test | def method_missing(method, *args, &block)
if method.to_s =~ /^asynch?_(.*)/
if instance_methods(false).detect{|meth| meth.to_s | ruby | {
"resource": ""
} |
q27301 | Woodhouse.Layout.add_node | test | def add_node(node)
if node.respond_to?(:to_sym)
node = Woodhouse::Layout::Node.new(node.to_sym) | ruby | {
"resource": ""
} |
q27302 | Woodhouse.Layout.node | test | def node(name)
name = name.to_sym
@nodes.detect{|node|
| ruby | {
"resource": ""
} |
q27303 | Scheherazade.CharacterBuilder.canonical | test | def canonical(attribute_list)
case attribute_list
when nil then {}
when Hash then attribute_list
when Array
attribute_list.map do |attributes|
case attributes
when Symbol
{attributes => AUTO}
when Hash
attributes
else
raise "Unexpected | ruby | {
"resource": ""
} |
q27304 | Scheherazade.Story.imagine | test | def imagine(character_or_model, attributes = nil)
character = to_character(character_or_model)
prev, @building = @building, [] # because method might be re-entrant
CharacterBuilder.new(character).build(attributes) do |ar|
ar.save!
# While errors on records associated with :has_many will prevent records
# from being saved, they won't for :belongs_to, so:
@building.each do |built|
| ruby | {
"resource": ""
} |
q27305 | Scheherazade.Story.with | test | def with(temp_current)
keys = temp_current.keys.map{|k| to_character(k)}
previous_values = current.values_at(*keys)
current.merge!(Hash[keys.zip(temp_current.values)])
| ruby | {
"resource": ""
} |
q27306 | DeferrableGratification.Primitives.failure | test | def failure(exception_class_or_message, message_or_nil = nil)
blank.tap do |d|
d.fail(
case exception_class_or_message
when Exception
raise ArgumentError, "can't specify both exception and message" if message_or_nil
exception_class_or_message
when Class
| ruby | {
"resource": ""
} |
q27307 | FantasticRobot.Request::SendAudio.file_length | test | def file_length
if self.audio.is_a?(File) && self.audio.size > MAX_FILE_SIZE
self.errors.add | ruby | {
"resource": ""
} |
q27308 | FantasticRobot.Connection.api_call | test | def api_call method, payload
raise ArgumentError, "API method not specified." if method.blank?
payload ||= {}
res = @conn.post method.to_s, payload
| ruby | {
"resource": ""
} |
q27309 | Oedipus.Index.multi_search | test | def multi_search(queries)
unless queries.kind_of?(Hash)
raise ArgumentError, "Argument must be a Hash of named queries (#{queries.class} given)"
end
stmts = []
bind_values = []
queries.each do |key, args|
str, *values = @builder.select(*extract_query_data(args))
| ruby | {
"resource": ""
} |
q27310 | Whereabouts.ClassMethods.has_whereabouts | test | def has_whereabouts klass=:address, *args
options = args.extract_options!
# extend Address with class name if not defined.
unless klass == :address || Object.const_defined?(klass.to_s.camelize)
create_address_class(klass.to_s.camelize)
end
# Set the has_one relationship and accepts_nested_attributes_for.
has_one klass, :as => :addressable, :dependent => :destroy
accepts_nested_attributes_for klass
# Define a singleton on the class that returns an array
# that includes the address fields to validate presence of
# or an empty array
if options[:validate] && options[:validate].is_a?(Array)
validators = options[:validate]
set_validators(klass, validators)
else
| ruby | {
"resource": ""
} |
q27311 | Whereabouts.ClassMethods.set_validators | test | def set_validators klass, fields=[]
_single = validate_singleton_for(klass)
klass.to_s.camelize.constantize.class_eval do
fields.each do |f|
validates_presence_of f,
| ruby | {
"resource": ""
} |
q27312 | Whereabouts.ClassMethods.create_address_class | test | def create_address_class(class_name, &block)
klass = Class.new Address, &block
| ruby | {
"resource": ""
} |
q27313 | Qwirk.Worker.event_loop | test | def event_loop
Qwirk.logger.debug "#{self}: Starting receive loop"
@start_worker_time = Time.now
until @stopped || (config.stopped? && @impl.ready_to_stop?)
Qwirk.logger.debug "#{self}: Waiting for read"
@start_read_time = Time.now
msg = @impl.receive_message
if msg
@start_processing_time = Time.now
Qwirk.logger.debug {"#{self}: Done waiting for read in #{@start_processing_time - @start_read_time} seconds"}
delta = config.timer.measure do
@processing_mutex.synchronize do
on_message(msg)
@impl.acknowledge_message(msg)
end
| ruby | {
"resource": ""
} |
q27314 | ActiveRecord.Base.arel_attributes_values | test | def arel_attributes_values(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
attrs = {}
attribute_names.each do |name|
if (column = column_for_attribute(name)) && (include_primary_key || !column.primary)
if include_readonly_attributes || (!include_readonly_attributes && !self.class.readonly_attributes.include?(name))
| ruby | {
"resource": ""
} |
q27315 | Bugzilla.Bugzilla.requires_version | test | def requires_version(cmd, version_)
v = check_version(version_)
raise NoMethodError, format('%s | ruby | {
"resource": ""
} |
q27316 | Clacks.Service.run | test | def run
begin
Clacks.logger.info "Clacks v#{Clacks::VERSION} started"
if Clacks.config[:pop3]
run_pop3
elsif Clacks.config[:imap]
run_imap
else
| ruby | {
"resource": ""
} |
q27317 | Clacks.Service.imap_validate_options | test | def imap_validate_options(options)
options ||= {}
options[:mailbox] ||= 'INBOX'
options[:count] ||= 5
options[:order] ||= :asc
options[:what] ||= :first
options[:keys] ||= 'ALL'
| ruby | {
"resource": ""
} |
q27318 | Clacks.Service.imap_find | test | def imap_find(imap)
options = Clacks.config[:find_options]
delete_after_find = options[:delete_after_find]
begin
break if stopping?
uids = imap.uid_search(options[:keys] || 'ALL')
uids.reverse! if options[:what].to_sym == :last
uids = uids.first(options[:count]) if options[:count].is_a?(Integer)
uids.reverse! if (options[:what].to_sym == :last && options[:order].to_sym == :asc) ||
(options[:what].to_sym != :last && options[:order].to_sym == :desc)
processed = 0
expunge = false
uids.each do |uid|
break if stopping?
source = imap.uid_fetch(uid, ['RFC822']).first.attr['RFC822']
mail = nil
begin
mail = Mail.new(source)
mail.mark_for_delete = true if delete_after_find
Clacks.config[:on_mail].call(mail)
rescue StandardError => e
Clacks.logger.error(e.message)
Clacks.logger.error(e.backtrace)
end
| ruby | {
"resource": ""
} |
q27319 | Ric.Colors.rainbow | test | def rainbow(str)
i=0
ret = ''
str=str.to_s
while(i < str.length)
ch = str[i]
palette = $color_db[0][i % $color_db[0].length ]
| ruby | {
"resource": ""
} |
q27320 | SecretSharing.Prime.large_enough_prime | test | def large_enough_prime(input)
standard_primes.each do |prime|
return prime if prime > input
end
| ruby | {
"resource": ""
} |
q27321 | SentenceBuilder.SentenceNode.enhance_content | test | def enhance_content(value, separator = ', ') | ruby | {
"resource": ""
} |
q27322 | SecretSharing.Charset.i_to_s | test | def i_to_s(input)
if !input.is_a?(Integer) || input < 0
fail NotPositiveInteger, "input must be a non-negative integer"
end
output = ""
while input > 0
input, | ruby | {
"resource": ""
} |
q27323 | SecretSharing.Charset.s_to_i | test | def s_to_i(string)
string.chars.reduce(0) do |output, char|
| ruby | {
"resource": ""
} |
q27324 | SecretSharing.Charset.char_to_codepoint | test | def char_to_codepoint(c)
codepoint = charset.index c
if codepoint.nil?
fail | ruby | {
"resource": ""
} |
q27325 | SecretSharing.Charset.subset? | test | def subset?(string)
(Set.new(string.chars) | ruby | {
"resource": ""
} |
q27326 | SecretSharing.Polynomial.points | test | def points(num_points, prime)
intercept = @coefficients[0] # the first coefficient is the intercept
(1..num_points).map do |x| | ruby | {
"resource": ""
} |
q27327 | Mead.EadValidator.validate! | test | def validate!
files = Dir.glob(File.join(@directory, '*.xml')).sort
threads = []
files.map do |path|
threads << Thread.new(path) do |path_t|
eadid = File.basename(path_t, '.xml')
begin
ead = Mead::Ead.new({:file => File.open(path_t), | ruby | {
"resource": ""
} |
q27328 | ActionCableNotifications.Model.notify_create | test | def notify_create
self.ChannelPublications.each do |publication, options|
if options[:actions].include? :create
# Checks if records is within scope before broadcasting
records = self.class.scoped_collection(options[:scope])
if options[:scope]==:all or record_within_scope(records) | ruby | {
"resource": ""
} |
q27329 | ActionCableNotifications.Model.notify_update | test | def notify_update
# Get model changes
if self.respond_to?(:saved_changes) # For Rails >= 5.1
changes = self.saved_changes.transform_values(&:second)
else # For Rails < 5.1
changes = self.changes.transform_values(&:second)
end
# Checks if there are changes in the model
if !changes.empty?
self.ChannelPublications.each do |publication, options|
if options[:actions].include? :update
# Checks if previous record was within scope
record = record_within_scope(options[:records])
was_in_scope = record.present?
options[:records].delete(record) if was_in_scope
# Checks if current record is within scope
if options[:track_scope_changes]==true
is_in_scope = false
if options[:scope]==:all
record = self
| ruby | {
"resource": ""
} |
q27330 | ActionCableNotifications.Model.notify_destroy | test | def notify_destroy
self.ChannelPublications.each do |publication, options|
if options[:scope]==:all or options[:actions].include? :destroy
# Checks if record is within scope before broadcasting
if options[:scope]==:all or record_within_scope(self.class.scoped_collection(options[:scope])).present?
| ruby | {
"resource": ""
} |
q27331 | Clacks.Configurator.logger | test | def logger(obj)
%w(debug info warn error fatal level).each do |m|
next if obj.respond_to?(m)
raise | ruby | {
"resource": ""
} |
q27332 | CurrencySpy.ScraperBase.fetch_rates | test | def fetch_rates
if self.class.superclass.eql?(Object)
raise Exception.new("This method should be invoked from CurrencySpy::Scraper sub class")
else
check_currency_code_validity
rate_results = {}
RATE_DATA.each do |rate|
symbol = rate.to_sym
| ruby | {
"resource": ""
} |
q27333 | FormatEngine.SpecInfo.parse | test | def parse(target)
#Handle the width option if specified.
if (width = fmt.width) > 0
head, tail = src[0...width], src[width..-1] || ""
else
head, tail = src, ""
end
#Do the parse on the input string or regex.
@prematch, @match, @postmatch = | ruby | {
"resource": ""
} |
q27334 | FormatEngine.SpecInfo.grab | test | def grab
width = fmt.width
if width > 0
result, @src = src[0...width], src[width..-1] || ""
elsif width == 0
result, @src = src[0...1], src[1..-1] || ""
elsif width == -1
result, @src = src, ""
| ruby | {
"resource": ""
} |
q27335 | Bugzilla.Bug.get_comments | test | def get_comments(bugs)
params = {}
# TODO
# this construction should be refactored to a method
params['ids'] = case bugs
when Array
bugs
when Integer || String
[bugs]
else
raise ArgumentError, format('Unknown type of arguments: %s', bugs.class)
end
result = comments(params)
# not supporting comment_ids. so drop "comments".
ret = result['bugs']
| ruby | {
"resource": ""
} |
q27336 | Qwirk.Manager.save_persist_state | test | def save_persist_state
return unless @persist_file
new_persist_options = {}
BaseWorker.worker_classes.each do |worker_class|
worker_class.each_config(@adapter_factory.worker_config_class) do |config_name, ignored_extended_worker_config_class, default_options|
static_options = default_options.merge(@worker_options[config_name] || {})
worker_config = self[config_name]
hash = {}
# Only store off the config values that are specifically different from default values or values set in the workers.yml file
# Then updates to these values will be allowed w/o being hardcoded to an old default value.
worker_config.bean_get_attributes do |attribute_info|
if attribute_info.attribute[:config_item] && attribute_info.ancestry.size == 1
| ruby | {
"resource": ""
} |
q27337 | Caramelize.RedmineWiki.read_pages | test | def read_pages
# get all projects
results_projects = database.query("SELECT id, identifier, name FROM projects;")
results_projects.each do |row_project|
#collect all namespaces
namespaces << OpenStruct.new(identifier: row_project["identifier"], name: row_project["name"])
end
# get all wikis
results_wikis = database.query("SELECT id, project_id FROM wikis;")
# get all lemmas
results_pages = database.query("SELECT id, title, wiki_id FROM wiki_pages;")
results_pages.each do |row_page|
results_contents = database.query("SELECT * FROM wiki_content_versions WHERE page_id='#{row_page["id"]}' ORDER BY updated_on;")
# get wiki for page
wiki_row = nil
project_row = nil
results_wikis.each do |wiki|
wiki_row = wiki if wiki["id"] == row_page["wiki_id"]
end
if wiki_row
# get project from wiki-id
results_projects.each do |project|
project_row = project if project["id"] == wiki_row["project_id"]
end
end
project_identifier = project_row ? project_row["identifier"] + '/' : ""
title = project_identifier + row_page["title"]
titles << title
@latest_revisions = {}
results_contents.each do |row_content|
| ruby | {
"resource": ""
} |
q27338 | Qwirk.PublishHandle.read_response | test | def read_response(timeout, &block)
raise "Invalid call to read_response for #{@producer}, not setup for responding" unless @producer.response_options
# Creates a block for reading the responses for a given message_id (adapter_info). The block will be passed an object
# that responds to timeout_read(timeout) with a [original_message_id, response_message, worker_name] tri or nil if no message is read.
# This is used in the RPC mechanism where a publish might wait for 1 or more workers to respond.
@producer.impl.with_response(@adapter_info) do |consumer|
if block_given?
return read_multiple_response(consumer, timeout, &block)
else
| ruby | {
"resource": ""
} |
q27339 | RakeCommandFilter.CommandDefinition.add_filter | test | def add_filter(id, pattern, &block)
filter | ruby | {
"resource": ""
} |
q27340 | Mixml.Selection.write | test | def write(template = nil)
if not template.nil? then
template = template.to_mixml_template
end
each_node do |node|
if template.nil? then
| ruby | {
"resource": ""
} |
q27341 | Mixml.Selection.replace | test | def replace(template)
template = template.to_mixml_template
each_node do |node|
| ruby | {
"resource": ""
} |
q27342 | Mixml.Selection.rename | test | def rename(template)
template = template.to_mixml_template
each_node do |node|
| ruby | {
"resource": ""
} |
q27343 | Caramelize.GollumOutput.commit_revision | test | def commit_revision(page, markup)
gollum_page = gollum.page(page.title)
if gollum_page
gollum.update_page(gollum_page, gollum_page.name, gollum_page.format, page.body, build_commit(page))
| ruby | {
"resource": ""
} |
q27344 | Caramelize.GollumOutput.commit_history | test | def commit_history(revisions, options = {}, &block)
options[:markup] = :markdown if !options[:markup] # target markup
revisions.each_with_index do |page, index|
# call debug output from outside
| ruby | {
"resource": ""
} |
q27345 | FormatEngine.FormatSpec.scan_spec | test | def scan_spec(fmt_string)
until fmt_string.empty?
if (match_data = PARSE_REGEX.match(fmt_string))
mid = match_data.to_s
pre = match_data.pre_match
@specs << FormatLiteral.new(pre) unless pre.empty?
@specs << case
when match_data[:var] then FormatVariable.new(mid)
when match_data[:set] then FormatSet.new(mid)
when match_data[:rgx] then FormatRgx.new(mid)
when match_data[:per] then FormatLiteral.new("\%")
| ruby | {
"resource": ""
} |
q27346 | Caramelize.TracConverter.to_textile | test | def to_textile str
body = body.dup
body.gsub!(/\r/, '')
body.gsub!(/\{\{\{([^\n]+?)\}\}\}/, '@\1@')
body.gsub!(/\{\{\{\n#!([^\n]+?)(.+?)\}\}\}/m, '<pre><code class="\1">\2</code></pre>')
body.gsub!(/\{\{\{(.+?)\}\}\}/m, '<pre>\1</pre>')
# macro
body.gsub!(/\[\[BR\]\]/, '')
body.gsub!(/\[\[PageOutline.*\]\]/, '{{toc}}')
body.gsub!(/\[\[Image\((.+?)\)\]\]/, '!\1!')
# header
body.gsub!(/=====\s(.+?)\s=====/, "h5. #{'\1'} \n\n")
body.gsub!(/====\s(.+?)\s====/, "h4. #{'\1'} \n\n")
body.gsub!(/===\s(.+?)\s===/, "h3. #{'\1'} \n\n")
body.gsub!(/==\s(.+?)\s==/, "h2. #{'\1'} \n\n")
body.gsub!(/=\s(.+?)\s=[\s\n]*/, "h1. #{'\1'} \n\n")
# table
body.gsub!(/\|\|/, "|")
# link
body.gsub!(/\[(http[^\s\[\]]+)\s([^\[\]]+)\]/, ' "\2":\1' )
| ruby | {
"resource": ""
} |
q27347 | Ric.Debug.debug2 | test | def debug2(s, opts = {} )
out = opts.fetch(:out, $stdout)
tag = opts.fetch(:tag, '_DFLT_')
really_write = opts.fetch(:really_write, true) # you can prevent ANY debug setting this to false
write_always = opts.fetch(:write_always, false)
raise "ERROR: ':tags' must be an array in debug(), maybe you meant to use :tag?" if ( opts[:tags] && opts[:tags].class != Array )
final_str = "#RDeb#{write_always ? '!' : ''}[#{opts[:tag] || '-'}] #{s}"
final_str = "\033[1;30m" +final_str + "\033[0m" if | ruby | {
"resource": ""
} |
q27348 | BarkestSsh.SecureShell.exec | test | def exec(command, options={}, &block)
raise ConnectionClosed.new('Connection is closed.') unless @channel
options = {
on_non_zero_exit_code: :default
}.merge(options || {})
options[:on_non_zero_exit_code] = @options[:on_non_zero_exit_code] if options[:on_non_zero_exit_code] == :default
push_buffer # store the current buffer and start a fresh buffer
# buffer while also passing data to the supplied block.
if block_given?
buffer_input( &block )
end
# send the command and wait for the prompt to return.
@channel.send_data command + "\n"
wait_for_prompt
# | ruby | {
"resource": ""
} |
q27349 | BarkestSsh.SecureShell.upload | test | def upload(local_file, remote_file)
raise ConnectionClosed.new('Connection | ruby | {
"resource": ""
} |
q27350 | BarkestSsh.SecureShell.download | test | def download(remote_file, local_file)
raise ConnectionClosed.new('Connection is closed.') unless @ssh
| ruby | {
"resource": ""
} |
q27351 | BarkestSsh.SecureShell.write_file | test | def write_file(remote_file, data)
raise ConnectionClosed.new('Connection is closed.') unless @ssh
| ruby | {
"resource": ""
} |
q27352 | GpsUtils.Point.distance | test | def distance(other)
unless other.is_a? Point
raise ArgumentError.new 'other must be a Point.'
end
dlng = GpsUtils::to_radians(other.lng - @lng)
dlat = GpsUtils::to_radians(other.lat - @lat)
x = dlng * | ruby | {
"resource": ""
} |
q27353 | GpsUtils.BoundingBox.cover? | test | def cover?(point)
p = [point.lat - @nw.lat, point.lng - @se.lng]
p21x = p[0] * @p21
p41x = p[1] * @p41
0 < | ruby | {
"resource": ""
} |
q27354 | MongoMapperExt.Paginator.send | test | def send(method, *args, &block)
if respond_to?(method)
super
else
| ruby | {
"resource": ""
} |
q27355 | RakeCommandFilter.LineFilterResult.output | test | def output(elapsed)
case @result
when MATCH_SUCCESS
color = :green
header = 'OK'
when MATCH_FAILURE
color = :red
header = 'FAIL'
when MATCH_WARNING
color = :light_red
header = 'WARN'
end
header | ruby | {
"resource": ""
} |
q27356 | Bugzilla.User.get_userinfo | test | def get_userinfo(user)
p = {}
ids = []
names = []
if user.is_a?(Array)
user.each do |u|
names << u if u.is_a?(String)
id << u if u.is_a?(Integer)
end
elsif user.is_a?(String)
names << user
elsif user.is_a?(Integer)
| ruby | {
"resource": ""
} |
q27357 | Dreader.Engine.options | test | def options &block
options = Options.new
| ruby | {
"resource": ""
} |
q27358 | Dreader.Engine.column | test | def column name, &block
column = Column.new
column.instance_eval(&block) | ruby | {
"resource": ""
} |
q27359 | Dreader.Engine.bulk_declare | test | def bulk_declare hash, &block
hash.keys.each do |key|
column = Column.new
column.colref hash[key]
if block
| ruby | {
"resource": ""
} |
q27360 | Dreader.Engine.read | test | def read args = {}
if args.class == Hash
hash = @options.merge(args)
else
puts "dreader error at #{__callee__}: this function takes a Hash as input"
exit
end
spreadsheet = Dreader::Engine.open_spreadsheet (hash[:filename])
sheet = spreadsheet.sheet(hash[:sheet] || 0)
@table = Array.new
@errors = Array.new
first_row = hash[:first_row] || 1
last_row = hash[:last_row] || sheet.last_row
(first_row..last_row).each do |row_number|
r = Hash.new
@colspec.each_with_index do |colspec, index|
cell = sheet.cell(row_number, colspec[:colref])
colname = colspec[:name]
r[colname] = Hash.new
r[colname][:row_number] = row_number
r[colname][:col_number] = colspec[:colref]
begin
r[colname][:value] = value = colspec[:process] ? colspec[:process].call(cell) : cell
rescue => e
puts "dreader error at #{__callee__}: 'process' specification for :#{colname} raised an exception at row #{row_number} (col #{index + 1}, value: #{cell})"
raise e
end
begin
| ruby | {
"resource": ""
} |
q27361 | Omelette.Util.backtrace_lineno_for_config | test | def backtrace_lineno_for_config(file_path, exception)
# For a SyntaxError, we really need to grep it from the
# exception message, it really appears to be nowhere else. Ugh.
if exception.kind_of? SyntaxError
if m = /:(\d+):/.match(exception.message)
return m[1].to_i
end
end
# Otherwise we try to fish it out of the backtrace, first
# line matching the config file path.
# exception.backtrace_locations exists in MRI 2.1+, which makes
# our task a lot easier. But not yet in JRuby 1.7.x, so we got to
# handle the old way of having to parse the strings in backtrace too.
if (exception.respond_to?(:backtrace_locations) &&
exception.backtrace_locations &&
exception.backtrace_locations.length > 0)
| ruby | {
"resource": ""
} |
q27362 | Omelette.Util.backtrace_from_config | test | def backtrace_from_config(file_path, exception)
filtered_trace = []
found = false
# MRI 2.1+ has exception.backtrace_locations which makes
# this a lot easier, but JRuby 1.7.x doesn't yet, so we
# need to do it both ways.
if (exception.respond_to?(:backtrace_locations) &&
exception.backtrace_locations &&
| ruby | {
"resource": ""
} |
q27363 | Omelette.Util.drain_queue | test | def drain_queue(queue)
result = []
queue_size = queue.size
begin
queue_size.times do
result | ruby | {
"resource": ""
} |
q27364 | SentenceBuilder.Builder.get_hash | test | def get_hash(params = {}, sorted = true)
| ruby | {
"resource": ""
} |
q27365 | SentenceBuilder.Builder.get_sentence | test | def get_sentence(params = {}, sorted = true, separator = ' ')
build_sentence_from_hash(get_hash(params, | ruby | {
"resource": ""
} |
q27366 | SentenceBuilder.Builder.get_nodes | test | def get_nodes(sorted = true)
SentenceBuilder::Helper.to_boolean(sorted) | ruby | {
"resource": ""
} |
q27367 | SentenceBuilder.Builder.build_sentence_from_hash | test | def build_sentence_from_hash(nodes)
result = []
nodes.each do |node|
# This node does not appear in params
if node[:current_value].nil?
| ruby | {
"resource": ""
} |
q27368 | Caramelize.WikkaWiki.read_pages | test | def read_pages
sql = "SELECT id, tag, body, time, latest, user, note FROM wikka_pages ORDER BY time;"
results = database.query(sql)
results.each do |row|
titles << row["tag"]
author = authors[row["user"]]
page = Page.new({:id => row["id"],
:title => row["tag"],
:body => row["body"],
:markup => :wikka,
:latest => row["latest"] == "Y",
:time => row["time"],
| ruby | {
"resource": ""
} |
q27369 | Filterable.ClassMethods.filter | test | def filter(params)
results = where(nil)
params.each do |key, value|
| ruby | {
"resource": ""
} |
q27370 | Trimark.Client.sites | test | def sites
response = conn.get("#{base_url}/site", {}, query_headers)
body = JSON.parse(response.body)
body.map { |b| Site.new(b) }
rescue | ruby | {
"resource": ""
} |
q27371 | Trimark.Client.site_query | test | def site_query(*args)
response = conn.get(url_picker(*args), {}, query_headers)
if response.body['SiteId'] || response.body['PointId']
JSON.parse(response.body)
else | ruby | {
"resource": ""
} |
q27372 | CurrencySpy.Walutomat.rate_time | test | def rate_time
regexp = Regexp.new(currency_code)
page.search("//span[@name='pair']").each do |td|
if regexp.match(td.content)
| ruby | {
"resource": ""
} |
q27373 | Logue.Logger.outfile= | test | def outfile= f
io = f.kind_of?(IO) ? f : File.new(f, "w")
| ruby | {
"resource": ""
} |
q27374 | Logue.Logger.log | test | def log msg = "", obj = nil, level: Level::DEBUG, classname: nil, &blk
log_frames msg, | ruby | {
"resource": ""
} |
q27375 | Watir.OptionGroup.options | test | def options
option_hash = {}
my_labels = option_names
my_inputs = option_fields
my_labels.count.times do |index|
| ruby | {
"resource": ""
} |
q27376 | Watir.OptionGroup.selected_options | test | def selected_options
selected = []
my_labels = option_names
inputs.each_with_index do |field, index|
| ruby | {
"resource": ""
} |
q27377 | ActionCableNotifications.Channel.transmit_packet | test | def transmit_packet(packet, options={})
# Default options
options = {
cache: false
}.merge(options)
packet = packet.as_json.deep_symbolize_keys
| ruby | {
"resource": ""
} |
q27378 | RBeautify.BlockStart.strict_ancestor_of? | test | def strict_ancestor_of?(block_start)
block_start && block_start.parent && (self == block_start.parent | ruby | {
"resource": ""
} |
q27379 | BuiltInData.ClassMethods.built_in_object_ids | test | def built_in_object_ids
@built_in_object_ids ||= Hash.new do |hash, key|
| ruby | {
"resource": ""
} |
q27380 | Clacks.Command.daemonize | test | def daemonize(safe = true)
$stdin.reopen '/dev/null'
# Fork and have the parent exit.
# This makes the shell or boot script think the command is done.
# Also, the child process is guaranteed not to be a process group
# leader (a prerequisite for setsid next)
exit if fork
# Call setsid to create a new session. This does three things:
# - The process becomes a session leader of a new session
# - The process becomes the process group leader of a new process group
# - The process has no controlling terminal
Process.setsid
# Fork again and have the parent exit.
# This guarantes that | ruby | {
"resource": ""
} |
q27381 | Clacks.Command.reopen_io | test | def reopen_io(io, path)
io.reopen(::File.open(path, "ab")) if | ruby | {
"resource": ""
} |
q27382 | Clacks.Command.running? | test | def running?(path)
wpid = ::File.read(path).to_i
return if wpid <= 0
Process.kill(0, wpid)
wpid
| ruby | {
"resource": ""
} |
q27383 | Clacks.Command.write_pid | test | def write_pid(pid)
::File.open(pid, 'w') { |f| f.write("#{Process.pid}") }
at_exit { | ruby | {
"resource": ""
} |
q27384 | Mead.Identifier.parse_mead | test | def parse_mead(*args)
parts = @mead.split('-')
args.each_with_index do |field, i|
| ruby | {
"resource": ""
} |
q27385 | Mixml.Tool.load | test | def load(*file_names)
file_names.flatten.each do |file_name|
xml = File.open(file_name, 'r') do |file|
Nokogiri::XML(file) do |config|
if @pretty then
config.default_xml.noblanks
| ruby | {
"resource": ""
} |
q27386 | Mixml.Tool.save_all | test | def save_all
output_all do |document, options|
File.open(document.name, 'w') do |file|
| ruby | {
"resource": ""
} |
q27387 | Mixml.Tool.print_all | test | def print_all
output_all do |document, options|
if @documents.size > 1 then
puts '-' * document.name.length
puts document.name
| ruby | {
"resource": ""
} |
q27388 | Mixml.Tool.work | test | def work(*file_names, &block)
remove_all
file_names.each do |file_name|
load(file_name)
if not block.nil? then
| ruby | {
"resource": ""
} |
q27389 | Mixml.Tool.xpath | test | def xpath(*paths, &block)
nodesets = []
process do |xml|
nodesets << xml.xpath(*paths)
end
selection = Selection.new(nodesets)
| ruby | {
"resource": ""
} |
q27390 | Mixml.Tool.css | test | def css(*selectors, &block)
nodesets = []
process do |xml|
nodesets << xml.css(*selectors)
end
selection = Selection.new(nodesets)
| ruby | {
"resource": ""
} |
q27391 | Mixml.Tool.execute | test | def execute(program = nil, &block)
if not program.nil? then
instance_eval(program)
| ruby | {
"resource": ""
} |
q27392 | Mixml.Tool.with_nodes | test | def with_nodes(selection)
selection.nodesets.each do |nodeset|
nodeset.each do |node|
| ruby | {
"resource": ""
} |
q27393 | TagFormatter.Formatter.tagify | test | def tagify input
output = input.dup
raise StandardError, "@tags is empty!" if @tags.empty? #improve on this
| ruby | {
"resource": ""
} |
q27394 | Watir.Container.option_group | test | def option_group(*args)
selector = if args.first.respond_to?(:elements)
args.first
else
| ruby | {
"resource": ""
} |
q27395 | Caramelize::CLI.CreateCommand.execute | test | def execute(args)
# create dummy config file
target_file = @config_file.nil? ? "caramel.rb" : @config_file
FileUtils.cp(File.dirname(__FILE__) +"/../caramel.rb", target_file)
if | ruby | {
"resource": ""
} |
q27396 | OscMacheteRails.Workflow.has_machete_workflow_of | test | def has_machete_workflow_of(jobs_active_record_relation_symbol)
# yes, this is magic mimicked from http://guides.rubyonrails.org/plugins.html
# and http://yehudakatz.com/2009/11/12/better-ruby-idioms/
cattr_accessor :jobs_active_record_relation_symbol
self.jobs_active_record_relation_symbol = jobs_active_record_relation_symbol
# separate modules to group common methods for readability purposes
# both builder methods and status methods need the jobs relation | ruby | {
"resource": ""
} |
q27397 | Qwirk.Task.check_retry | test | def check_retry
if @finished_publishing && @pending_hash.empty? && @exception_count > 0 && (@retry || @auto_retry)
# If we're just doing auto_retry but nothing succeeded last time, then don't run again
return if !@retry && @auto_retry && @exception_count == @exceptions_per_run.last
Qwirk.logger.info "#{self}: Retrying exception records, exception count = #{@exception_count}"
@exceptions_per_run << @exception_count
@exception_count = 0
@finished_publishing = false
@fail_thread = Thread.new(@exceptions_per_run.last) do |count|
begin
java.lang.Thread.current_thread.name = "Qwirk fail task: #{task_id}"
while !@stopped && (count > 0) && | ruby | {
"resource": ""
} |
q27398 | Mixml.Application.run | test | def run
program :name, 'mixml'
program :version, Mixml::VERSION
program :description, 'XML helper tool'
$tool = Mixml::Tool.new
global_option('-p', '--pretty', 'Pretty print output') do |value|
$tool.pretty = value
end
global_option('-i', '--inplace', 'Replace the processed files with the new files') do |value|
$tool.save = value
$tool.print = !value
end
global_option('-q', '--quiet', 'Do not print nodes') do |value|
$tool.print = !value
end
command :pretty do |c|
c.description = 'Pretty print XML files'
c.action do |args, options|
$tool.pretty = true
$tool.work(args)
end
end
modify_command :write do |c|
| ruby | {
"resource": ""
} |
q27399 | Koi.Command.list | test | def list entities = @db.list
out
entities = entities.is_a?(Fixnum) ? @db.list[0...entities] : entities
entities.reject {|e| e[:status] == :removed }.each_with_index do |e, i|
out " [#{i}]".blue +
"#{e.sticky?? " + ".bold : " "}" +
e[:title].underline +
" #{e[:tags].join(' ')}".cyan
| ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.