_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q26100 | CaTissue.Database.add_position_to_specimen_template | validation | def add_position_to_specimen_template(specimen, template)
pos = specimen.position
# the non-domain position attributes
pas = pos.class.nondomain_attributes
# the template position reflects the old values, if available
ss = pos.snapshot
# the attribute => value hash
vh = ss ? pa... | ruby | {
"resource": ""
} |
q26101 | CaTissue.Database.ensure_primary_annotation_has_hook | validation | def ensure_primary_annotation_has_hook(annotation)
hook = annotation.hook
if hook.nil? then
raise CaRuby::DatabaseError.new("Cannot save annotation #{annotation} since it does not reference a hook entity")
end
if hook.identifier.nil? then
logger.debug { "Ensuring that the annotat... | ruby | {
"resource": ""
} |
q26102 | CaTissue.Database.copy_annotation_proxy_owner_to_template | validation | def copy_annotation_proxy_owner_to_template(obj, template)
prop = obj.class.proxy_property
# Ignore the proxy attribute if it is defined by caRuby rather than caTissue.
return unless prop and prop.java_property?
rdr, wtr = prop.java_accessors
pxy = obj.send(rdr)
logger.debug { "Setti... | ruby | {
"resource": ""
} |
q26103 | Sycsvpro.Table.create_table_data | validation | def create_table_data
processed_header = false
File.open(infile).each_with_index do |line, index|
line = line.chomp
next if line.empty?
line = unstring(line).chomp
header.process line, processed_header
unless processed_header
processed_header = ... | ruby | {
"resource": ""
} |
q26104 | Sycsvpro.Table.write_to_file | validation | def write_to_file
File.open(outfile, 'w') do |out|
out.puts header.to_s
out.puts create_sum_row if @sum_row_pos == 'TOP'
rows.each do |key, row|
line = [] << row[:key]
header.clear_header_cols.each_with_index do |col, index|
next if index < row[:key].size
... | ruby | {
"resource": ""
} |
q26105 | Sycsvpro.Table.to_number | validation | def to_number(value)
value = convert_to_en(value)
return value.to_i unless value =~ /\./
return value.to_f if value =~ /\./
end | ruby | {
"resource": ""
} |
q26106 | Sycsvpro.Table.prepare_sum_row | validation | def prepare_sum_row(pattern)
return if pattern.nil? || pattern.empty?
@sum_row_pos, sum_row_pattern = pattern.split(/(?<=^top|^eof):/i)
@sum_row_pos.upcase!
@sum_row = Hash.new
@sum_row_patterns = split_by_comma_regex(sum_row_pattern)
end | ruby | {
"resource": ""
} |
q26107 | Sycsvpro.Table.add_to_sum_row | validation | def add_to_sum_row(value, column)
return unless @sum_row_patterns
@sum_row_patterns.each do |pattern|
if pattern =~ /^\(?c\d+[=~+.]/
header_column = evaluate(pattern, "")
else
header_column = pattern
end
if header_column == column
... | ruby | {
"resource": ""
} |
q26108 | Sycsvpro.Table.create_sum_row | validation | def create_sum_row
line = []
header.clear_header_cols.each do |col|
line << @sum_row[col] || ""
end
line.flatten.join(';')
end | ruby | {
"resource": ""
} |
q26109 | TranslatedCollection.Wrapper._rewrap_array | validation | def _rewrap_array(result)
if @wrap_results
newcoll = @collection.class.new(result)
self.class.new(newcoll, @wrapfunc_in, @wrapfunc_out)
else
@collection.class.new(result.map(&@wrapfunc_out))
end
end | ruby | {
"resource": ""
} |
q26110 | DeepEnd.Graph.add_dependency | validation | def add_dependency(key, dependencies = [])
raise SelfDependencyError, "An object's dependencies cannot contain itself" if dependencies.include? key
node = node_for_key_or_new key
dependencies.each do |dependency|
node.addEdge(node_for_key_or_new(dependency))
end
resolve_dependenc... | ruby | {
"resource": ""
} |
q26111 | DeepEnd.Graph.resolve_dependency | validation | def resolve_dependency(node)
node.seen = true
@seen_this_pass << node
node.edges.each do |edge|
unless @resolved.include? edge
unless @seen_this_pass.include? edge
unless edge.seen?
resolve_dependency edge
end
else
raise Ci... | ruby | {
"resource": ""
} |
q26112 | Turntabler.RoomDirectory.with_friends | validation | def with_friends
data = api('room.directory_graph')
data['rooms'].map do |(attrs, friends)|
Room.new(client, attrs.merge(:friends => friends))
end
end | ruby | {
"resource": ""
} |
q26113 | Turntabler.RoomDirectory.find | validation | def find(query, options = {})
assert_valid_keys(options, :limit, :skip)
options = {:limit => 20, :skip => 0}.merge(options)
data = api('room.search', :query => query, :skip => options[:skip])
data['rooms'].map {|(attrs, *)| Room.new(client, attrs)}
end | ruby | {
"resource": ""
} |
q26114 | Turntabler.Playlist.load | validation | def load(options = {})
assert_valid_keys(options, :minimal)
options = {:minimal => false}.merge(options)
data = api('playlist.all', options)
self.attributes = data
super()
end | ruby | {
"resource": ""
} |
q26115 | Turntabler.Playlist.update | validation | def update(attributes = {})
assert_valid_keys(attributes, :id)
# Update id
id = attributes.delete(:id)
update_id(id) if id
true
end | ruby | {
"resource": ""
} |
q26116 | Turntabler.Playlist.active | validation | def active
@active = client.user.playlists.all.any? {|playlist| playlist == self && playlist.active?} if @active.nil?
@active
end | ruby | {
"resource": ""
} |
q26117 | AttributesDSL.Attributes.add | validation | def add(name, options = {}, &coercer)
name = name.to_sym
value = Attribute.new(name, options, &coercer)
clone_with do
@attributes = attributes.merge(name => value)
@transformer = nil
end
end | ruby | {
"resource": ""
} |
q26118 | CaTissue.CollectionProtocol.add_specimens | validation | def add_specimens(*args)
hash = args.pop
spcs = args
# validate arguments
unless Hash === hash then
raise ArgumentError.new("Collection parameters are missing when adding specimens to protocol #{self}")
end
# Make the default registration, if necessary.
unless hash.has_... | ruby | {
"resource": ""
} |
q26119 | Sightstone.SummonerModule.summoner | validation | def summoner(name_or_id, optional={})
region = optional[:region] || @sightstone.region
uri = if name_or_id.is_a? Integer
"https://prod.api.pvp.net/api/lol/#{region}/v1.3/summoner/#{name_or_id}"
else
"https://prod.api.pvp.net/api/lol/#{region}/v1.3/summoner/by-name/#{URI::encode(name_or_id)}"
... | ruby | {
"resource": ""
} |
q26120 | Sightstone.SummonerModule.names | validation | def names(ids, optional={})
region = optional[:region] || @sightstone.region
ids = ids.join(',')
uri = "https://prod.api.pvp.net/api/lol/#{region}/v1.3/summoner/#{ids}/name"
response = _get_api_response(uri)
_parse_response(response) { |resp|
data = JSON.parse(resp)
names_hash = Hash.ne... | ruby | {
"resource": ""
} |
q26121 | Sightstone.SummonerModule.runebook | validation | def runebook(summoner, optional={})
region = optional[:region] || @sightstone.region
id = if summoner.is_a? Summoner
summoner.id
else
summoner
end
uri = "https://prod.api.pvp.net/api/lol/#{region}/v1.3/summoner/#{id}/runes"
response = _get_api_response(uri)
_parse_response(respon... | ruby | {
"resource": ""
} |
q26122 | Sightstone.SummonerModule.runebooks | validation | def runebooks(summoners, optional={})
return {} if summoners.empty?
region = optional[:region] || @sightstone.region
ids = summoners.collect { |summoner|
if summoner.is_a? Summoner
summoner.id
else
summoner
end
}
uri = "https://prod.api.pvp.net/api/lol/#{region}/v1... | ruby | {
"resource": ""
} |
q26123 | Zipper.ZipFileGenerator.write | validation | def write
buffer = create_zip(@entries, @ignore_entries)
puts "\nwrite file #{@output_file}"
File.open(@output_file, "wb") {|f| f.write buffer.string }
end | ruby | {
"resource": ""
} |
q26124 | CaTissue.Collectible.collect | validation | def collect(opts)
raise Jinx::ValidationError.new("#{self} is already collected") if received?
specimen_event_parameters.merge!(extract_event_parameters(opts))
end | ruby | {
"resource": ""
} |
q26125 | Sycsvpro.Filter.method_missing | validation | def method_missing(id, *args, &block)
boolean_row_regex = %r{
BEGIN(\(*[nsd]\d+[<!=~>]{1,2}
(?:[A-Z][A-Za-z]*\.new\(.*?\)|\d+|['"].*?['"])
(?:\)*(?:&&|\|\||$)
\(*[nsd]\d+[<!=~>]{1,2}
(?:[A-Z][A-Za-z]*\.new\(.*?\)|\d+|['"].*?['"])\)*)*)END
}xi
return boolean... | ruby | {
"resource": ""
} |
q26126 | Sycsvpro.Filter.match_boolean_filter? | validation | def match_boolean_filter?(values=[])
return false if boolean_filter.empty? or values.empty?
expression = boolean_filter
columns = expression.scan(/(([nsd])(\d+))([<!=~>]{1,2})(.*?)(?:[\|&]{2}|$)/)
columns.each do |c|
value = case c[1]
when 'n'
values[c[2].to_i].empty? ?... | ruby | {
"resource": ""
} |
q26127 | Sycsvpro.Filter.pivot_each_column | validation | def pivot_each_column(values=[])
pivot.each do |column, parameters|
value = values[parameters[:col].to_i]
value = value.strip.gsub(/^"|"$/, "") unless value.nil?
match = false
begin
match = eval(parameters[:operation].gsub('[value]', value))
rescue Exception => e
... | ruby | {
"resource": ""
} |
q26128 | Sycsvpro.Filter.create_filter | validation | def create_filter(values)
values.scan(/(?<=,|^)(BEGIN.*?END|\/.*?\/|.*?)(?=,|$)/i).flatten.each do |value|
send(value)
end unless values.nil?
end | ruby | {
"resource": ""
} |
q26129 | Sycsvpro.Filter.equal | validation | def equal(value, args, block)
filter << value.to_i unless filter.index(value.to_i)
end | ruby | {
"resource": ""
} |
q26130 | Sycsvpro.Filter.equal_type | validation | def equal_type(type, value, args, block)
filter_size_before = filter.size
equal(value, args, block)
types << type if filter_size_before < filter.size
end | ruby | {
"resource": ""
} |
q26131 | Sycsvpro.Filter.range | validation | def range(start_value, end_value, args, block)
filter << (start_value.to_i..end_value.to_i).to_a
end | ruby | {
"resource": ""
} |
q26132 | Sycsvpro.Filter.range_type | validation | def range_type(type, start_value, end_value, args, block)
filter_size_before = filter.size
range(start_value, end_value, args, block)
(filter.size - filter_size_before).times { types << type }
end | ruby | {
"resource": ""
} |
q26133 | Sycsvpro.Filter.col_regex | validation | def col_regex(col, r, args, block)
operation = "'[value]' =~ Regexp.new('#{r}')"
pivot[r] = { col: col, operation: operation }
end | ruby | {
"resource": ""
} |
q26134 | Sycsvpro.Filter.date | validation | def date(col, comparator, date, args, block)
comparator = '==' if comparator == '='
operation = "Date.strptime(\"[value]\", \"#{date_format}\") #{comparator} " +
"Date.strptime(\"#{date}\", \"#{date_format}\")"
pivot["#{comparator}#{date}"] = { col: col, operation: operation ... | ruby | {
"resource": ""
} |
q26135 | Sycsvpro.Filter.date_range | validation | def date_range(col, start_date, end_date, args, block)
operation = " Date.strptime(\"#{start_date}\", \"#{date_format}\") " +
"<= Date.strptime(\"[value]\", \"#{date_format}\") && " +
" Date.strptime(\"[value]\", \"#{date_format}\") " +
... | ruby | {
"resource": ""
} |
q26136 | Sycsvpro.Filter.number | validation | def number(col, comparator, number, args, block)
comparator = '==' if comparator == '='
operation = "[value] #{comparator} #{number}"
pivot["#{comparator}#{number}"] = { col: col, operation: operation }
end | ruby | {
"resource": ""
} |
q26137 | Sycsvpro.Filter.number_range | validation | def number_range(col, start_number, end_number, arg, block)
operation = " #{start_number} <= [value] && [value] <= #{end_number}"
pivot["#{start_number}-#{end_number}"] = { col: col, operation: operation }
end | ruby | {
"resource": ""
} |
q26138 | CaTissue.JBridge.create_annotation | validation | def create_annotation(hook, annotation)
# validate the arguments
if hook.nil? then raise ArgumentError.new("Annotated caTissue object is missing") end
if annotation.nil? then raise ArgumentError.new("Annotation caTissue object is missing") end
# the annotated object must exist in the database
... | ruby | {
"resource": ""
} |
q26139 | SeriesJoiner.ArrayAdditions.join_as_series | validation | def join_as_series(options = {})
if defined?(I18n)
default_delimiter = I18n.translate(:'series_joiner.default_delimiter', :locale => options[:locale])
default_final_delimiter = I18n.translate(:'series_joiner.default_final_delimiter', :locale => options[:locale])
default_conjunc... | ruby | {
"resource": ""
} |
q26140 | Ragabash.AwesomeStringFormatter.awesome_string | validation | def awesome_string(string)
lexers = ::Rouge::Guessers::Source.new(string).filter(R_LEXERS)
if !lexers.empty?
format_syntax_string(string, lexers.first)
elsif string =~ /(?:\r?\n)(?!\z)/
format_multiline_string(string)
else
format_plain_string(string)
end
end | ruby | {
"resource": ""
} |
q26141 | Papercat.Page.meta= | validation | def meta=val
val = JSON.parse(val) if val.is_a?(String)
write_store_attribute(:data, :meta, val)
end | ruby | {
"resource": ""
} |
q26142 | Sycsvpro.Collector.execute | validation | def execute
File.new(infile).each_with_index do |line, index|
row = row_filter.process(line, row: index)
next if row.nil? or row.chomp.empty?
collection.each do |category, elements|
values = elements[:filter].process(row)
values.chomp.split(';').each do |value|
... | ruby | {
"resource": ""
} |
q26143 | Sycsvpro.Collector.init_collection | validation | def init_collection(column_filter)
column_filter.split('+').each do |f|
category, filter = f.split(':')
collection[category] = { entries: [], filter: ColumnFilter.new(filter) }
end
end | ruby | {
"resource": ""
} |
q26144 | Spark.Fire.log | validation | def log
out.sync = true
@log ||= Logger.new(out)
@log.formatter = proc do |severity, datetime, progname, msg|
if verbose
string = "#{severity} [#{datetime.strftime('%Y-%m-%d %H:%M:%S.%2N')}]: "
else
string = "[#{datetime.strftime('%H:%M:%S')}]: "
end
... | ruby | {
"resource": ""
} |
q26145 | MiniAether.Require.require_aether | validation | def require_aether *deps
@mini_aether_require_spec ||= MiniAether::Spec.new
@mini_aether_require_resolver ||= MiniAether::Resolver.new
spec = @mini_aether_require_spec
resolver = @mini_aether_require_resolver
if deps.last.kind_of?(Hash)
hash = deps.pop
[hash[:source], has... | ruby | {
"resource": ""
} |
q26146 | Sycsvpro.Join.create_lookup_table | validation | def create_lookup_table
File.open(source).each_with_index do |line|
next if line.chomp.empty?
values = unstring(line).chomp.split(';')
next if values.empty?
@joiners.each do |joiner|
key = values[joiner.join[0]]
joiner.lookup[:rows][key] = []
... | ruby | {
"resource": ""
} |
q26147 | Sycsvpro.Join.col_positions | validation | def col_positions(pos, cols)
if pos.nil? || pos.empty?
pos = []
cols.each { |c| pos << Array.new(c.size) { |c| c } }
pos
else
pos.split(';').collect { |p| p.split(',').collect { |p| p.to_i } }
end
end | ruby | {
"resource": ""
} |
q26148 | Sycsvpro.Join.create_joiners | validation | def create_joiners(j, c, p)
js = j.split(';').collect { |j| j.split('=').collect { |j| j.to_i } }
cs = c.split(';').collect { |c| c.split(',').collect { |c| c.to_i } }
ps = col_positions(p, cs)
@joiners = []
(0...js.size).each do |i|
@joiners << Joiner.new(js[i], ps[i... | ruby | {
"resource": ""
} |
q26149 | CaTissue.SpecimenProtocol.add_defaults_local | validation | def add_defaults_local
super
self.title ||= short_title
self.short_title ||= title
self.start_date ||= Java::JavaUtil::Date.new
end | ruby | {
"resource": ""
} |
q26150 | Sycsvpro.SpreadSheet.[] | validation | def [](*range)
r, c = range
r ||= 0..(nrows-1)
c ||= 0..(ncols-1)
row_selection = rows.values_at(*r)
col_selection = []
if rows_are_arrays?(row_selection)
row_selection.each do |row|
values = row.values_at(*c)
col_selection << (values.respond_to?(:to_ar... | ruby | {
"resource": ""
} |
q26151 | Sycsvpro.SpreadSheet.column_collect | validation | def column_collect(&block)
result = []
0.upto(ncols-1) { |i| result << block.call(self[nil,i]) }
result
end | ruby | {
"resource": ""
} |
q26152 | Sycsvpro.SpreadSheet.rename | validation | def rename(opts = {})
if opts[:rows]
opts[:rows] = opts[:rows][0,nrows]
opts[:rows] += row_labels[opts[:rows].size, nrows]
end
if opts[:cols]
opts[:cols] = opts[:cols][0,ncols]
opts[:cols] += col_labels[opts[:cols].size, ncols]
end
@row_labels = opts[:rows... | ruby | {
"resource": ""
} |
q26153 | Sycsvpro.SpreadSheet.to_s | validation | def to_s
col_label_sizes = col_labels.collect { |c| c.to_s.size + 2 }
row_label_size = row_labels.collect { |r| r.to_s.size + 2 }.max
row_col_sizes = rows.transpose.collect { |r| r.collect { |c| c.to_s.size } }
i = -1
col_sizes = col_label_sizes.collect do |s|
i += 1
[r... | ruby | {
"resource": ""
} |
q26154 | Sycsvpro.SpreadSheet.rows_from_params | validation | def rows_from_params(opts)
col_count = opts[:cols]
row_count = opts[:rows]
size = row_count * col_count if row_count && col_count
rows = []
if values = opts[:values]
if size
values += [NotAvailable] * (size - values.size)
elsif col_cou... | ruby | {
"resource": ""
} |
q26155 | Sycsvpro.SpreadSheet.equalize_rows | validation | def equalize_rows(rows)
column_sizes = rows.collect { |r| r.size }
return rows if column_sizes.uniq.size == 1
max_size = column_sizes.max
small_rows = []
column_sizes.each_with_index { |c,i| small_rows << i if c < max_size }
small_rows.each do |i|
rows[i] +=... | ruby | {
"resource": ""
} |
q26156 | Sycsvpro.SpreadSheet.same_column_size? | validation | def same_column_size?(rows)
offset = opts[:c] ? 1 : 0
return true if rows.size == 1 + offset
(0 + offset).upto(rows.size - 2) do |i|
return false unless rows[i].size == rows[i+1].size
end
true
end | ruby | {
"resource": ""
} |
q26157 | Sycsvpro.SpreadSheet.coerce | validation | def coerce(value)
return SpreadSheet.new([value]) if value.is_a?(Numeric)
return SpreadSheet.new(value) if value.is_a?(Array)
end | ruby | {
"resource": ""
} |
q26158 | Sycsvpro.SpreadSheet.process | validation | def process(operator, s)
s = coerce(s) || s
raise "operand needs to be a SpreadSheet, "+
"Numeric or Array" unless s.is_a?(SpreadSheet)
result = []
rlabel = []
clabel = []
s1_row_count, s1_col_count = dim
s2_row_count, s2_col_count = s.dim
ro... | ruby | {
"resource": ""
} |
q26159 | Sycsvpro.Counter.process_count | validation | def process_count
File.new(infile).each_with_index do |line, index|
result = col_filter.process(row_filter.process(line.chomp, row: index))
unless result.nil? or result.empty?
key = unstring(line).split(';').values_at(*key_columns)
key_value = key_values[key] || key_values[key]... | ruby | {
"resource": ""
} |
q26160 | Sycsvpro.Counter.write_result | validation | def write_result
sum_line = [sum_row_title] + [''] * (key_titles.size - 1)
headline = heading_sort ? heading.sort : original_pivot_sequence_heading
headline << add_sum_col unless sum_col_title.nil?
headline.each do |h|
sum_line << sums[h]
end
row = 0;
File.open(outfile,... | ruby | {
"resource": ""
} |
q26161 | Sycsvpro.Counter.init_sum_scheme | validation | def init_sum_scheme(sum_scheme)
return if sum_scheme.nil?
re = /(\w+):(\d+)|(\w+)/
sum_scheme.scan(re).each do |part|
if part.compact.size == 2
@sum_row_title = part[0]
@sum_row = part[1].to_i
else
@sum_col_title = part[2]
... | ruby | {
"resource": ""
} |
q26162 | Sycsvpro.Counter.init_key_columns | validation | def init_key_columns(key_scheme)
@key_titles = []
@key_columns = []
keys = key_scheme.scan(/(\d+):(\w+)/)
keys.each do |key|
@key_titles << key[1]
@key_columns << key[0].to_i
end
end | ruby | {
"resource": ""
} |
q26163 | Sycsvpro.Counter.original_pivot_sequence_heading | validation | def original_pivot_sequence_heading
(heading.sort - col_filter.pivot.keys << col_filter.pivot.keys).flatten
end | ruby | {
"resource": ""
} |
q26164 | Sycsvpro.RowFilter.process | validation | def process(object, options={})
object = unstring(object)
return object unless has_filter?
filtered = !filter.flatten.uniq.index(options[:row]).nil?
pattern.each do |p|
filtered = (filtered or !(object =~ Regexp.new(p)).nil?)
end
filtered = (filtered or match_boolean_filter?(... | ruby | {
"resource": ""
} |
q26165 | Turntabler.User.messages | validation | def messages
data = api('pm.history', :receiverid => id)
data['history'].map {|attrs| Message.new(client, attrs)}
end | ruby | {
"resource": ""
} |
q26166 | Turntabler.User.stalk | validation | def stalk
become_fan unless client.user.fan_of.include?(self)
client.rooms.with_friends.detect do |room|
room.listener(id)
end
end | ruby | {
"resource": ""
} |
q26167 | Turntabler.User.boot | validation | def boot(reason = '')
api('room.boot_user', :roomid => room.id, :section => room.section, :target_userid => id, :reason => reason)
true
end | ruby | {
"resource": ""
} |
q26168 | Turntabler.User.report | validation | def report(reason = '')
api('room.report_user', :roomid => room.id, :section => room.section, :reported => id, :reason => reason)
true
end | ruby | {
"resource": ""
} |
q26169 | CaTissue.AbstractSpecimen.default_derived_characteristics | validation | def default_derived_characteristics
chrs = specimen_characteristics || return
pas = chrs.class.nondomain_attributes.reject { |pa| pa == :identifier }
chrs.copy(pas)
end | ruby | {
"resource": ""
} |
q26170 | MapKit.MapView.region= | validation | def region=(args)
case args
when Hash
self.setRegion(CoordinateRegion.new(args[:region]).api, animated: args[:animated])
else
self.setRegion(CoordinateRegion.new(args).api, animated: false)
end
end | ruby | {
"resource": ""
} |
q26171 | CaTissue.Participant.collection_site | validation | def collection_site
return unless medical_identifiers.size == 1
site = medical_identifiers.first.site
return if site.nil?
site.site_type == Site::SiteType::COLLECTION ? site : nil
end | ruby | {
"resource": ""
} |
q26172 | CaTissue.SpecimenRequirement.match_characteristics | validation | def match_characteristics(other)
chr = characteristics
ochr = other.characteristics
chr and ochr and chr.tissue_side == ochr.tissue_side and chr.tissue_site == ochr.tissue_site
end | ruby | {
"resource": ""
} |
q26173 | CaTissue.ReceivedEventParameters.default_user | validation | def default_user
scg = specimen_collection_group || (specimen.specimen_collection_group if specimen) || return
cp = scg.collection_protocol || return
cp.coordinators.first || (cp.sites.first.coordinator if cp.sites.size === 1)
end | ruby | {
"resource": ""
} |
q26174 | Dune::Dashboard.I18n.export! | validation | def export!
puts "Exporting translations:\n"
if config[:split]
translations.keys.each do |locale|
if translations[:en].nil?
puts 'Missing english translation'
exit
end
puts "\nLocale: #{locale}"
fallback_english_hash = flat_hash(transla... | ruby | {
"resource": ""
} |
q26175 | Dune::Dashboard.I18n.save | validation | def save(translations, file)
file = ::Rails.root.join(file)
FileUtils.mkdir_p File.dirname(file)
variable_to_assign = config.fetch(:variable, 'Ember.I18n.translations')
File.open(file, 'w+') do |f|
f << variable_to_assign
f << ' = '
f << JSON.pretty_generate(translation... | ruby | {
"resource": ""
} |
q26176 | Dune::Dashboard.I18n.translations | validation | def translations
::I18n.load_path = default_locales_path
::I18n.backend.instance_eval do
init_translations unless initialized?
translations
end
end | ruby | {
"resource": ""
} |
q26177 | CaTissue.PropertiesLoader.load_properties | validation | def load_properties
# the properties file
file = default_properties_file
# the access properties
props = file && File.exists?(file) ? load_properties_file(file) : {}
# Load the Java application jar path.
path = props[:classpath] || props[:path] || infer_classpath
Java.expand_to... | ruby | {
"resource": ""
} |
q26178 | Vatsim.Data.parse | validation | def parse
download_files
parsing_clients = false
parsing_prefile = false
parsing_general = false
parsing_servers = false
parsing_voice_servers = false
File.open(DATA_FILE_PATH, 'r:ascii-8bit').each { |line|
if line.start_with? ";"
parsing_clients = false
... | ruby | {
"resource": ""
} |
q26179 | Vatsim.Data.download_files | validation | def download_files
if !File.exists?(STATUS_FILE_PATH) or File.mtime(STATUS_FILE_PATH) < Time.now - STATUS_DOWNLOAD_INTERVAL
download_to_file STATUS_URL, STATUS_FILE_PATH
end
if !File.exists?(DATA_FILE_PATH) or File.mtime(DATA_FILE_PATH) < Time.now - DATA_DOWNLOAD_INTERVAL
download_to_f... | ruby | {
"resource": ""
} |
q26180 | Vatsim.Data.download_to_file | validation | def download_to_file url, file
url = URI.parse(URI.encode(url.strip))
File.new(file, File::CREAT)
Net::HTTP.start(url.host) { |http|
resp = http.get(url.path)
open(file, "wb") { |file|
file.write(resp.body)
}
}
end | ruby | {
"resource": ""
} |
q26181 | Vatsim.Data.random_data_url | validation | def random_data_url
url0s = Array.new
file = File.open(STATUS_FILE_PATH)
file.each {|line|
if line.start_with? "url0"
url0s << line.split("=").last
end
}
return url0s[rand(url0s.length)]
end | ruby | {
"resource": ""
} |
q26182 | NewRelicManagement.Util.cachier! | validation | def cachier!(var = nil)
if var && instance_variable_get("@#{var}")
# => Clear the Single Variable
remove_instance_variable("@#{var}")
else
# => Clear the Whole Damned Cache
instance_variables.each { |x| remove_instance_variable(x) }
end
end | ruby | {
"resource": ""
} |
q26183 | NewRelicManagement.Util.write_json | validation | def write_json(file, object)
return unless file && object
begin
File.open(file, 'w') { |f| f.write(JSON.pretty_generate(object)) }
end
end | ruby | {
"resource": ""
} |
q26184 | NewRelicManagement.Util.filestring | validation | def filestring(file, size = 8192)
return unless file
return file unless file.is_a?(String) && File.file?(file) && File.size(file) <= size
File.read(file)
end | ruby | {
"resource": ""
} |
q26185 | NewRelicManagement.Util.common_array | validation | def common_array(ary) # rubocop: disable AbcSize
return ary unless ary.is_a? Array
count = ary.count
return ary if count.zero?
return ary.flatten.uniq if count == 1
common = ary[0] & ary[1]
return common if count == 2
(count - 2).times { |x| common &= ary[x + 2] } if count > 2
... | ruby | {
"resource": ""
} |
q26186 | Isimud.EventListener.run | validation | def run
bind_queues and return if test_env?
start_shutdown_thread
start_error_counter_thread
client.on_exception do |e|
count_error(e)
end
client.connect
start_event_thread
puts 'EventListener started. Hit Ctrl-C to exit'
Thread.stop
puts 'Main thread... | ruby | {
"resource": ""
} |
q26187 | Isimud.EventListener.register_observer_class | validation | def register_observer_class(observer_class)
@observer_mutex.synchronize do
return if @observed_models.include?(observer_class)
@observed_models << observer_class
log "EventListener: registering observer class #{observer_class}"
observer_queue.bind(models_exchange, routing_key: "#{I... | ruby | {
"resource": ""
} |
q26188 | Isimud.EventListener.register_observer | validation | def register_observer(observer)
@observer_mutex.synchronize do
log "EventListener: registering observer #{observer.class} #{observer.id}"
@observers[observer_key_for(observer.class, observer.id)] = observer.observe_events(client)
end
end | ruby | {
"resource": ""
} |
q26189 | Isimud.EventListener.unregister_observer | validation | def unregister_observer(observer_class, observer_id)
@observer_mutex.synchronize do
log "EventListener: un-registering observer #{observer_class} #{observer_id}"
if (consumer = @observers.delete(observer_key_for(observer_class, observer_id)))
consumer.cancel
end
end
end | ruby | {
"resource": ""
} |
q26190 | Isimud.EventListener.observer_queue | validation | def observer_queue
@observer_queue ||= client.create_queue([name, 'listener', Socket.gethostname, Process.pid].join('.'),
models_exchange,
queue_options: {exclusive: true},
... | ruby | {
"resource": ""
} |
q26191 | Isimud.Event.as_json | validation | def as_json(options = {})
session_id = parameters.delete(:session_id) || Thread.current[:keas_session_id]
data = {type: type,
action: action,
user_id: user_id,
occurred_at: occurred_at,
eventful_type: eventful_type,
... | ruby | {
"resource": ""
} |
q26192 | MrPoole.CLI.do_create | validation | def do_create(action)
options = do_creation_options
options.title ||= @params.first
@helper.send("#{action}_usage") unless options.title
fn = @commands.send(action, options)
puts "#{@src_dir}/#{fn}"
end | ruby | {
"resource": ""
} |
q26193 | MrPoole.CLI.do_move | validation | def do_move(action)
options = do_move_options(action)
path = @params.first
@helper.send("#{action}_usage") unless path
fn = @commands.send(action, path, options)
puts "#{@src_dir}/#{fn}"
end | ruby | {
"resource": ""
} |
q26194 | MrPoole.CLI.do_move_options | validation | def do_move_options(type)
options = OpenStruct.new
opt_parser = OptionParser.new do |opts|
if type == 'publish'
opts.on('-d', '--keep-draft', "Keep draft post") do |d|
options.keep_draft = d
end
else
opts.on('-p', '--keep-post', "Do not delete post")... | ruby | {
"resource": ""
} |
q26195 | YARD.RelativeMarkdownLinks.resolve_links | validation | def resolve_links(text)
html = Nokogiri::HTML.fragment(text)
html.css("a[href]").each do |link|
href = URI(link["href"])
next unless href.relative? && markup_for_file(nil, href.path) == :markdown
link.replace "{file:#{href} #{link.inner_html}}"
end
super(html.to_s)
en... | ruby | {
"resource": ""
} |
q26196 | NewRelicManagement.Client.nr_api | validation | def nr_api
# => Build the Faraday Connection
@conn ||= Faraday::Connection.new('https://api.newrelic.com', conn_opts) do |client|
client.use Faraday::Response::RaiseError
client.use FaradayMiddleware::EncodeJson
client.use FaradayMiddleware::ParseJson, content_type: /\bjson$/
... | ruby | {
"resource": ""
} |
q26197 | NewRelicManagement.Client.alert_add_entity | validation | def alert_add_entity(entity_id, condition_id, entity_type = 'Server')
nr_api.put do |req|
req.url url('alerts_entity_conditions', entity_id)
req.params['entity_type'] = entity_type
req.params['condition_id'] = condition_id
end
end | ruby | {
"resource": ""
} |
q26198 | NewRelicManagement.Client.alert_delete_entity | validation | def alert_delete_entity(entity_id, condition_id, entity_type = 'Server')
nr_api.delete do |req|
req.url url('alerts_entity_conditions', entity_id)
req.params['entity_type'] = entity_type
req.params['condition_id'] = condition_id
end
end | ruby | {
"resource": ""
} |
q26199 | NewRelicManagement.Client.get_server_id | validation | def get_server_id(server_id)
return nil unless server_id =~ /^[0-9]+$/
ret = nr_api.get(url('servers', server_id)).body
ret['server']
rescue Faraday::ResourceNotFound, NoMethodError
nil
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.