_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 66
10.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q5600
|
Saddle.Requester.delete
|
train
|
def delete(url, params={}, options={})
response = connection.delete do |req|
req.saddle_options = options
req.url(url, params)
end
handle_response(response)
end
|
ruby
|
{
"resource": ""
}
|
q5601
|
Saddle.Requester.connection
|
train
|
def connection
@connection ||= Faraday.new(base_url, :builder_class => Saddle::RackBuilder) do |connection|
# Include the requester level options
connection.builder.saddle_options[:client_options] = @options
# Config options
connection.options[:timeout] = @timeout
connection.builder.saddle_options[:request_style] = @request_style
connection.builder.saddle_options[:num_retries] = @num_retries
connection.builder.saddle_options[:client] = @parent_client
# Support default return values upon exception
connection.use(Saddle::Middleware::Response::DefaultResponse)
# Hard timeout on the entire request
connection.use(Saddle::Middleware::RubyTimeout)
# Set up a user agent
connection.use(Saddle::Middleware::Request::UserAgent)
# Set up the path prefix if needed
connection.use(Saddle::Middleware::Request::PathPrefix)
# Apply additional implementation-specific middlewares
@additional_middlewares.each do |m|
m[:args] ? connection.use(m[:klass], *m[:args]) : connection.use(m[:klass])
end
# Request encoding
connection.use(Saddle::Middleware::Request::JsonEncoded)
connection.use(Saddle::Middleware::Request::UrlEncoded)
# Automatic retries
connection.use(Saddle::Middleware::Request::Retry)
# Raise exceptions on 4xx and 5xx errors
connection.use(Saddle::Middleware::Response::RaiseError)
# Handle parsing out the response if it's JSON
connection.use(Saddle::Middleware::Response::ParseJson)
# Set up instrumentation around the adapter for extensibility
connection.use(FaradayMiddleware::Instrumentation)
# Add in extra env data if needed
connection.use(Saddle::Middleware::ExtraEnv)
# Set up our adapter
if @stubs.nil?
# Use the default adapter
connection.adapter(@http_adapter[:key], *@http_adapter[:args])
else
# Use the test adapter
connection.adapter(:test, @stubs)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q5602
|
DEVS.Container.remove_child
|
train
|
def remove_child(child)
child = child.name if child.is_a?(Model)
children.delete(child)
end
|
ruby
|
{
"resource": ""
}
|
q5603
|
DEVS.Container.attach
|
train
|
def attach(p1, to:, between: nil, and: nil)
p2 = to
sender = between
# use binding#local_variable_get because 'and:' keyword argument clashes
# with the language reserved keyword.
receiver = binding.local_variable_get(:and)
raise ArgumentError.new("'between:' keyword was omitted, 'p1' should be a Port.") if sender.nil? && !p1.is_a?(Port)
raise ArgumentError.new("'and:' keyword was omitted, 'to:' should be a Port") if receiver.nil? && !p2.is_a?(Port)
a = if p1.is_a?(Port) then p1.host
elsif sender.is_a?(Coupleable) then sender
elsif sender == @name then self
else fetch_child(sender); end
b = if p2.is_a?(Port) then p2.host
elsif receiver.is_a?(Coupleable) then receiver
elsif receiver == @name then self
else fetch_child(receiver); end
if has_child?(a) && has_child?(b) # IC
p1 = a.output_port(p1) unless p1.is_a?(Port)
p2 = b.input_port(p2) unless p2.is_a?(Port)
raise InvalidPortTypeError.new unless p1.output? && p2.input?
raise FeedbackLoopError.new("#{a} must be different than #{b}") if a.object_id == b.object_id
_internal_couplings[p1] << p2
elsif a == self && has_child?(b) # EIC
p1 = a.input_port(p1) unless p1.is_a?(Port)
p2 = b.input_port(p2) unless p2.is_a?(Port)
raise InvalidPortTypeError.new unless p1.input? && p2.input?
_input_couplings[p1] << p2
elsif has_child?(a) && b == self # EOC
p1 = a.output_port(p1) unless p1.is_a?(Port)
p2 = b.output_port(p2) unless p2.is_a?(Port)
raise InvalidPortTypeError.new unless p1.output? && p2.output?
_output_couplings[p1] << p2
else
raise InvalidPortHostError.new("Illegal coupling between #{p1} and #{p2}")
end
end
|
ruby
|
{
"resource": ""
}
|
q5604
|
AppRepo.Manifest.manifest_as_json
|
train
|
def manifest_as_json
structure = {
appcode: appcode,
filename: filename,
bundle_identifier: bundle_identifier,
bundle_version: bundle_version,
title: title,
subtitle: subtitle,
notify: notify
}
fputs structure
end
|
ruby
|
{
"resource": ""
}
|
q5605
|
Calligraphy.FileResource.copy_options
|
train
|
def copy_options(options)
copy_options = { can_copy: false, ancestor_exist: false, locked: false }
destination = copy_destination options
to_path = join_paths @root_dir, destination
to_path_exists = File.exist? to_path
copy_options[:ancestor_exist] = File.exist? parent_path destination
copy_options[:locked] = can_copy_locked_option to_path, to_path_exists
copy_options = can_copy_option copy_options, options, to_path_exists
copy_options
end
|
ruby
|
{
"resource": ""
}
|
q5606
|
StatModule.Process.print
|
train
|
def print(formatted = nil)
result = name
unless version.nil?
result += ", version #{version}"
end
if formatted
result = "#{FORMATTING_STAR.colorize(:yellow)} #{result}"
end
result
end
|
ruby
|
{
"resource": ""
}
|
q5607
|
HtmlSlicer.Interface.source
|
train
|
def source
case options[:processors].present?
when true then HtmlSlicer::Process.iterate(@env.send(@method_name), options[:processors])
else
@env.send(@method_name)
end
end
|
ruby
|
{
"resource": ""
}
|
q5608
|
HtmlSlicer.Interface.slice!
|
train
|
def slice!(slice = nil)
raise(Exception, "Slicing unavailable!") unless sliced?
if slice.present?
if slice.to_i.in?(1..slice_number)
@current_slice = slice.to_i
else
raise(ArgumentError, "Slice number must be Integer in (1..#{slice_number}). #{slice.inspect} passed.")
end
end
self
end
|
ruby
|
{
"resource": ""
}
|
q5609
|
HtmlSlicer.Interface.view
|
train
|
def view(node, slice, &block)
slice = slice.to_i
case node
when ::HTML::Tag then
children_view = node.children.map {|child| view(child, slice, &block)}.compact.join
if resized?
resizing.resize_node(node)
end
if sliced?
if slicing.map.get(node, slice) || children_view.present?
if node.closing == :close
"</#{node.name}>"
else
s = "<#{node.name}"
node.attributes.each do |k,v|
s << " #{k}"
s << "=\"#{v}\"" if String === v
end
s << " /" if node.closing == :self
s << ">"
s += children_view
s << "</#{node.name}>" if node.closing != :self && !node.children.empty?
s
end
end
else
node.to_s
end
when ::HTML::Text then
if sliced?
if range = slicing.map.get(node, slice)
(range.is_a?(Array) ? node.content[Range.new(*range)] : node.content).tap do |export|
unless range == true || (range.is_a?(Array) && range.last == -1) # broken text
export << slicing.options.text_break if slicing.options.text_break
if block_given?
yield self, export
end
end
end
end
else
node.to_s
end
when ::HTML::CDATA then
node.to_s
when ::HTML::Node then
node.children.map {|child| view(child, slice, &block)}.compact.join
end
end
|
ruby
|
{
"resource": ""
}
|
q5610
|
Cassie::Schema.Versioning.version
|
train
|
def version
SelectVersionsQuery.new.fetch_first || Version.new('0')
rescue Cassandra::Errors::InvalidError
raise uninitialized_error
end
|
ruby
|
{
"resource": ""
}
|
q5611
|
Cassie::Schema.Versioning.record_version
|
train
|
def record_version(version, set_execution_metadata=true)
time = Time.now
version.id ||= Cassandra::TimeUuid::Generator.new.at(time)
if set_execution_metadata
version.executed_at = time
version.executor = Etc.getlogin rescue '<unknown>'
end
InsertVersionQuery.new(version: version).execute!
@applied_versions = nil
rescue StandardError => e
version.id = nil
version.executed_at = nil
version.executor = nil
raise e
end
|
ruby
|
{
"resource": ""
}
|
q5612
|
Cassie::Schema.Versioning.load_applied_versions
|
train
|
def load_applied_versions
database_versions.tap do |versions|
versions.each{|v| VersionObjectLoader.new(v).load }
end
rescue Cassandra::Errors::InvalidError => e
raise uninitialized_error
end
|
ruby
|
{
"resource": ""
}
|
q5613
|
SlackRTM.Client.init
|
train
|
def init
return if @has_been_init
@socket = init_socket(@socket)
@socket.connect # costly and blocking !
internalWrapper = (Struct.new :url, :socket do
def write(*args)
self.socket.write(*args)
end
end).new @url.to_s, @socket
# this, also, is costly and blocking
@driver = WebSocket::Driver.client internalWrapper
@driver.on :open do
@connected = true
unless @callbacks[:open].nil?
@callbacks[:open].call
end
end
@driver.on :error do |event|
@connected = false
unless @callbacks[:error].nil?
@callbacks[:error].call
end
end
@driver.on :message do |event|
data = JSON.parse event.data
unless @callbacks[:message].nil?
@callbacks[:message].call data
end
end
@driver.start
@has_been_init = true
end
|
ruby
|
{
"resource": ""
}
|
q5614
|
SlackRTM.Client.inner_loop
|
train
|
def inner_loop
return if @stop
data = @socket.readpartial 4096
return if data.nil? or data.empty?
@driver.parse data
@msg_queue.each {|msg| @driver.text msg}
@msg_queue.clear
end
|
ruby
|
{
"resource": ""
}
|
q5615
|
CLIUtils.Messenger.error
|
train
|
def error(m)
puts _word_wrap(m, '# ').red
@targets.each { |_, t| t.error(m) }
end
|
ruby
|
{
"resource": ""
}
|
q5616
|
CLIUtils.Messenger.info
|
train
|
def info(m)
puts _word_wrap(m, '# ').blue
@targets.each { |_, t| t.info(m) }
end
|
ruby
|
{
"resource": ""
}
|
q5617
|
CLIUtils.Messenger.section
|
train
|
def section(m)
puts _word_wrap(m, '---> ').purple
@targets.each { |_, t| t.section(m) }
end
|
ruby
|
{
"resource": ""
}
|
q5618
|
CLIUtils.Messenger.success
|
train
|
def success(m)
puts _word_wrap(m, '# ').green
@targets.each { |_, t| t.success(m) }
end
|
ruby
|
{
"resource": ""
}
|
q5619
|
CLIUtils.Messenger.warn
|
train
|
def warn(m)
puts _word_wrap(m, '# ').yellow
@targets.each { |_, t| t.warn(m) }
end
|
ruby
|
{
"resource": ""
}
|
q5620
|
LatexToPng.Convert.size_in_points
|
train
|
def size_in_points size_in_pixels
size = Sizes.invert[size_in_pixels]
return (size.nil?)? size_in_points("#{size_in_pixels.to_i + 1}px") : size
end
|
ruby
|
{
"resource": ""
}
|
q5621
|
Opencnam.Parsers.parse_json
|
train
|
def parse_json(json)
hash = JSON.parse(json, :symbolize_names => true)
# Convert hash[:created] and hash[:updated] to Time objects
if hash[:created]
hash.merge!({ :created => parse_iso_date_string(hash[:created]) })
end
if hash[:updated]
hash.merge!({ :updated => parse_iso_date_string(hash[:updated]) })
end
hash
end
|
ruby
|
{
"resource": ""
}
|
q5622
|
Giraph.Schema.execute
|
train
|
def execute(query, **args)
args = args
.merge(with_giraph_root(args))
.merge(with_giraph_resolvers(args))
super(query, **args)
end
|
ruby
|
{
"resource": ""
}
|
q5623
|
Pod.CDNSource.specification_path
|
train
|
def specification_path(name, version)
raise ArgumentError, 'No name' unless name
raise ArgumentError, 'No version' unless version
relative_podspec = pod_path_partial(name).join("#{version}/#{name}.podspec.json")
download_file(relative_podspec)
pod_path(name).join("#{version}/#{name}.podspec.json")
end
|
ruby
|
{
"resource": ""
}
|
q5624
|
PayDirt.UseCase.load_options
|
train
|
def load_options(*required_options, options)
# Load required options
required_options.each { |o| options = load_option(o, options) }
# Load remaining options
options.each_key { |k| options = load_option(k, options) }
block_given? ? yield : options
end
|
ruby
|
{
"resource": ""
}
|
q5625
|
Saddle.MethodTreeBuilder.build_tree
|
train
|
def build_tree(requester)
root_node = build_root_node(requester)
# Search out the implementations directory structure for endpoints
if defined?(self.implementation_root)
# For each endpoints directory, recurse down it to load the modules
endpoints_directories.each do |endpoints_directories|
Dir["#{endpoints_directories}/**/*.rb"].each { |f| require(f) }
end
build_node_children(self.endpoints_module, root_node, requester)
end
root_node
end
|
ruby
|
{
"resource": ""
}
|
q5626
|
Saddle.MethodTreeBuilder.build_root_node
|
train
|
def build_root_node(requester)
if defined?(self.implementation_root)
root_endpoint_file = File.join(
self.implementation_root,
'root_endpoint.rb'
)
if File.file?(root_endpoint_file)
warn "[DEPRECATION] `root_endpoint.rb` is deprecated. Please use `ABSOLUTE_PATH` in your endpoints."
# Load it and create our base endpoint
require(root_endpoint_file)
# RootEndpoint is the special class name for a root endpoint
root_node_class = self.implementation_module::RootEndpoint
else
# 'root_endpoint.rb' doesn't exist, so create a dummy endpoint
root_node_class = Saddle::RootEndpoint
end
else
# we don't even have an implementation root, so create a dummy endpoint
root_node_class = Saddle::RootEndpoint
end
root_node_class.new(requester, nil, self)
end
|
ruby
|
{
"resource": ""
}
|
q5627
|
Saddle.MethodTreeBuilder.build_node_children
|
train
|
def build_node_children(current_module, current_node, requester)
return unless current_module
current_module.constants.each do |const_symbol|
const = current_module.const_get(const_symbol)
if const.class == Module
# A module means that it's a branch
# Build the branch out with a base endpoint
branch_node = current_node._build_and_attach_node(
Saddle::TraversalEndpoint,
const_symbol.to_s.underscore
)
# Build out the branch's endpoints on the new branch node
self.build_node_children(const, branch_node, requester)
end
if const < Saddle::TraversalEndpoint
# A class means that it's a node
# Build out this endpoint on the current node
current_node._build_and_attach_node(const)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q5628
|
FormAPI.Client.combine_submissions
|
train
|
def combine_submissions(options)
unless options[:submission_ids].is_a?(::Array)
raise InvalidDataError, "submission_ids is required, and must be an Array."
end
options[:source_pdfs] = options[:submission_ids].map do |id|
{ type: 'submission', id: id }
end
options.delete :submission_ids
combine_pdfs(options)
end
|
ruby
|
{
"resource": ""
}
|
q5629
|
DEVS.AtomicModel.ensure_output_port
|
train
|
def ensure_output_port(port)
raise ArgumentError, "port argument cannot be nil" if port.nil?
unless port.kind_of?(Port)
port = output_port(port)
raise ArgumentError, "the given port doesn't exists" if port.nil?
end
unless port.host == self
raise InvalidPortHostError, "The given port doesn't belong to this \
model"
end
unless port.output?
raise InvalidPortTypeError, "The given port isn't an output port"
end
port
end
|
ruby
|
{
"resource": ""
}
|
q5630
|
CronSpec.CronSpecification.is_specification_in_effect?
|
train
|
def is_specification_in_effect?(time=Time.now)
idx = 0
test_results = @cron_values.collect do | cvalues |
time_value = time.send(TimeMethods[idx])
idx += 1
!cvalues.detect { | cv | cv.is_effective?(time_value) }.nil?
end.all?
end
|
ruby
|
{
"resource": ""
}
|
q5631
|
Rubychain.Block.hash_block
|
train
|
def hash_block
hash_string = [index,timestamp,data,prev_hash].join
sha = Digest::SHA256.new
sha.update(hash_string)
sha.hexdigest
end
|
ruby
|
{
"resource": ""
}
|
q5632
|
CLIUtils.Prefs.ask
|
train
|
def ask
# First, deliver all the prompts that don't have
# any prerequisites.
@prompts.reject { |p| p.prereqs }.each do |p|
_deliver_prompt(p)
end
# After the "non-prerequisite" prompts are delivered,
# deliver any that require prerequisites.
@prompts.select { |p| p.prereqs }.each do |p|
_deliver_prompt(p) if _prereqs_fulfilled?(p)
end
end
|
ruby
|
{
"resource": ""
}
|
q5633
|
CLIUtils.Prefs._prereqs_fulfilled?
|
train
|
def _prereqs_fulfilled?(p)
ret = true
p.prereqs.each do |req|
a = @prompts.find do |answer|
answer.config_key == req[:config_key] &&
answer.answer == req[:config_value]
end
ret = false if a.nil?
end
ret
end
|
ruby
|
{
"resource": ""
}
|
q5634
|
Opee.AskQueue.ask_worker
|
train
|
def ask_worker(worker, job)
raise NoMethodError.new("undefined method for #{job.class}. Expected a method invocation") unless job.is_a?(Actor::Act)
worker.ask(job.op, *job.args)
end
|
ruby
|
{
"resource": ""
}
|
q5635
|
ISE.Project.set_property
|
train
|
def set_property(name, value, mark_non_default=true)
#Set the node's property, as specified.
node = get_property_node(name)
node.attribute("value").value = value
#If the mark non-default option is set, mark the state is not a default value.
node.attribute("valueState").value = 'non-default' if mark_non_default
end
|
ruby
|
{
"resource": ""
}
|
q5636
|
ISE.Project.minimize_runtime!
|
train
|
def minimize_runtime!
#Compute the path in which temporary synthesis files should be created.
shortname = CGI::escape(get_property(ShortNameProperty))
temp_path = Dir::mktmpdir([shortname, ''])
#Synthesize from RAM.
set_property(WorkingDirectoryProperty, temp_path)
#Ask the project to focus on runtime over performance.
set_property(GoalProperty, 'Minimum Runtime')
end
|
ruby
|
{
"resource": ""
}
|
q5637
|
ISE.Project.top_level_file
|
train
|
def top_level_file(absolute_path=true)
path = get_property(TopLevelFileProperty)
#If the absolute_path flag is set, and we know how, expand the file path.
if absolute_path
path = File.expand_path(path, @base_path)
end
#Return the relevant path.
path
end
|
ruby
|
{
"resource": ""
}
|
q5638
|
ISE.Project.bit_file
|
train
|
def bit_file
#Determine ISE's working directory.
working_directory = get_property(WorkingDirectoryProperty)
#Find an absolute path at which the most recently generated bit file should reside.
name = get_property(OutputNameProperty)
name = File.expand_path("#{working_directory}/#{name}.bit", @base_path)
#If it exists, return it.
File::exists?(name) ? name : nil
end
|
ruby
|
{
"resource": ""
}
|
q5639
|
HtmlSlicer.Installer.slice
|
train
|
def slice(*args, &block)
attr_name = args.first
raise(NameError, "Attribute name expected!") unless attr_name
options = args.extract_options!
config = HtmlSlicer.config(options.delete(:config)).duplicate # Configuration instance for each single one implementation
if options.present? # Accepts options from args
options.each do |key, value|
config.send("#{key}=", value)
end
end
if block_given? # Accepts options from block
yield config
end
if config.processors
Array.wrap(config.processors).each do |name|
HtmlSlicer.load_processor!(name)
end
end
method_name = config.as||"#{attr_name}_slice"
config.cache_to = "#{method_name}_cache" if config.cache_to == true
class_eval do
define_method method_name do
var_name = "@_#{method_name}"
instance_variable_get(var_name)||instance_variable_set(var_name, HtmlSlicer::Interface.new(self, attr_name, config.config))
end
end
if config.cache_to && self.superclass == ActiveRecord::Base
before_save do
send(method_name).load!
end
end
end
|
ruby
|
{
"resource": ""
}
|
q5640
|
Uniqable.ClassMethods.uniqable
|
train
|
def uniqable(*fields, to_param: nil)
fields = [:uid] if fields.blank?
fields.each do |name|
before_create { |record| record.uniqable_uid(name) }
end
define_singleton_method :uniqable_fields do
fields
end
return if to_param.blank? # :to_param option
define_method :to_param do
public_send(to_param)
end
end
|
ruby
|
{
"resource": ""
}
|
q5641
|
Paperweight.Download.normalize_download
|
train
|
def normalize_download(file)
return file unless file.is_a?(StringIO)
# We need to open it in binary mode for Windows users.
Tempfile.new('download-', binmode: true).tap do |tempfile|
# IO.copy_stream is the most efficient way of data transfer.
IO.copy_stream(file, tempfile.path)
# We add the metadata that open-uri puts on the file
# (e.g. #content_type)
OpenURI::Meta.init(tempfile)
end
end
|
ruby
|
{
"resource": ""
}
|
q5642
|
Cassie::Schema.StructureDumper.keyspace_structure
|
train
|
def keyspace_structure
@keyspace_structure ||= begin
args = ["-e", "'DESCRIBE KEYSPACE #{Cassie.configuration[:keyspace]}'"]
runner = Cassie::Support::SystemCommand.new("cqlsh", args)
runner.succeed
runner.output
end
end
|
ruby
|
{
"resource": ""
}
|
q5643
|
DocbookStatus.Status.remarks
|
train
|
def remarks(keyword=nil)
if keyword.nil?
@remarks
else
ukw = keyword.upcase
@remarks.find_all {|r| r[:keyword] == (ukw)}
end
end
|
ruby
|
{
"resource": ""
}
|
q5644
|
DocbookStatus.Status.find_section_title
|
train
|
def find_section_title(node)
title = node.find_first('./db:title')
if title.nil?
title = node.find_first './db:info/db:title'
end
if title.nil?
""
else
title.content
end
end
|
ruby
|
{
"resource": ""
}
|
q5645
|
DocbookStatus.Status.check_node
|
train
|
def check_node(node, level, ctr)
if (@@text_elements.include? node.name)
ctr << {:type => :para, :level => level, :words => count_content_words(node)}
elsif (@@section_elements.include? node.name)
title = find_section_title(node)
ctr << {:type => :section, :level => level, :title => title, :name => node.name}
node.children.each {|inner_elem| check_node(inner_elem, level+1, ctr)} if node.children?
else
node.children.each {|inner_elem| check_node(inner_elem, level+1, ctr)} if node.children?
end
ctr
end
|
ruby
|
{
"resource": ""
}
|
q5646
|
DocbookStatus.Status.is_docbook?
|
train
|
def is_docbook?(doc)
dbns = doc.root.namespaces.default
(!dbns.nil? && (dbns.href.casecmp(DOCBOOK_NS) == 0))
end
|
ruby
|
{
"resource": ""
}
|
q5647
|
DocbookStatus.Status.has_xinclude?
|
train
|
def has_xinclude?(doc)
ret = false
doc.root.namespaces.each do |ns|
if (ns.href.casecmp(XINCLUDE_NS) == 0)
ret = true
break
end
end
ret
end
|
ruby
|
{
"resource": ""
}
|
q5648
|
DocbookStatus.Status.find_remarks
|
train
|
def find_remarks(filter=[])
if (@source.nil?)
rfiles = find_xincludes(@doc)
else
@doc = XML::Document.file(@source)
rfiles = [@source_file] + find_xincludes(@doc)
end
@remarks = rfiles.map {|rf|
ind = XML::Document.file(File.expand_path(rf,@source.nil? ? '.' : @source_dir))
ind.root.namespaces.default_prefix = 'db'
rems = find_remarks_in_doc(ind, rf)
rems
}.flatten
if (filter.empty?)
@remarks
else
filter.map {|f|
@remarks.find_all {|r| f.casecmp(r[:keyword]) == 0}
}.flatten
end
end
|
ruby
|
{
"resource": ""
}
|
q5649
|
DocbookStatus.Status.sum_lower_sections
|
train
|
def sum_lower_sections(secs,start,level)
i=start
sum = 0
while (i < secs.length && secs[i][:level] > level)
sum += secs[i][:words]
i += 1
end
[sum,i]
end
|
ruby
|
{
"resource": ""
}
|
q5650
|
DocbookStatus.Status.sum_sections
|
train
|
def sum_sections(secs, max_level)
0.upto(max_level) do |cur_level|
i = 0
while i < secs.length
if (secs[i][:level] == cur_level)
(ctr,ni) = sum_lower_sections(secs, i+1,cur_level)
secs[i][:swords] = ctr
i = ni
else
i += 1
end
end
end
secs
end
|
ruby
|
{
"resource": ""
}
|
q5651
|
DocbookStatus.Status.analyze_file
|
train
|
def analyze_file
full_name = File.expand_path(@source)
changed = File.mtime(@source)
@doc = XML::Document.file(@source)
raise ArgumentError, "Error: #{@source} is apparently not DocBook 5." unless is_docbook?(@doc)
@doc.xinclude if has_xinclude?(@doc)
sections = analyze_document(@doc)
{:file => full_name, :modified => changed, :sections => sections}
end
|
ruby
|
{
"resource": ""
}
|
q5652
|
AppRepo.Runner.upload_binary
|
train
|
def upload_binary
if options[:ipa]
uploader = AppRepo::Uploader.new(options)
result = uploader.upload
msg = 'Binary upload failed. Check out the error above.'
UI.user_error!(msg) unless result
end
end
|
ruby
|
{
"resource": ""
}
|
q5653
|
AutoGraphQL.TypeBuilder.convert_type
|
train
|
def convert_type type
return type if type.is_a? GraphQL::BaseType
unless type.is_a? Symbol
type = type.to_s.downcase.to_sym
end
{
boolean: GraphQL::BOOLEAN_TYPE,
date: GraphQL::Types::DATE,
datetime: GraphQL::Types::ISO8601DateTime,
decimal: GraphQL::Types::DECIMAL,
float: GraphQL::FLOAT_TYPE,
int: GraphQL::INT_TYPE,
integer: GraphQL::INT_TYPE,
json: GraphQL::Types::JSON,
string: GraphQL::STRING_TYPE,
text: GraphQL::STRING_TYPE,
}[type]
end
|
ruby
|
{
"resource": ""
}
|
q5654
|
RepoManager.RepoAsset.scm
|
train
|
def scm
return @scm if @scm
raise NoSuchPathError unless File.exists?(path)
raise InvalidRepositoryError unless File.exists?(File.join(path, '.git'))
@scm = Git.open(path)
end
|
ruby
|
{
"resource": ""
}
|
q5655
|
Cassie::Schema.Version.next
|
train
|
def next(bump_type=nil)
bump_type ||= :patch
bump_index = PARTS.index(bump_type.to_sym)
# 0.2.1 - > 0.2
bumped_parts = parts.take(bump_index + 1)
# 0.2 - > 0.3
bumped_parts[bump_index] = bumped_parts[bump_index].to_i + 1
# 0.3 - > 0.3.0.0
bumped_parts += [0]*(PARTS.length - (bump_index + 1))
self.class.new(bumped_parts.join('.'))
end
|
ruby
|
{
"resource": ""
}
|
q5656
|
Git.Lib.native
|
train
|
def native(cmd, opts = [], chdir = true, redirect = '', &block)
validate
ENV['GIT_DIR'] = @git_dir
ENV['GIT_INDEX_FILE'] = @git_index_file
ENV['GIT_WORK_TREE'] = @git_work_dir
path = @git_work_dir || @git_dir || @path
opts = [opts].flatten.map {|s| escape(s) }.join(' ')
git_cmd = "git #{cmd} #{opts} #{redirect} 2>&1"
out = nil
if chdir && (Dir.getwd != path)
Dir.chdir(path) { out = run_command(git_cmd, &block) }
else
out = run_command(git_cmd, &block)
end
if @logger
@logger.info(git_cmd)
@logger.debug(out)
end
if $?.exitstatus > 0
if $?.exitstatus == 1 && out == ''
return ''
end
raise Git::CommandFailed.new(git_cmd, $?.exitstatus, out.to_s)
end
out
end
|
ruby
|
{
"resource": ""
}
|
q5657
|
Rubychain.Chain.add_next_block
|
train
|
def add_next_block(prev_block, data)
if valid_block?(prev_block)
blockchain << next_block(data)
else
raise InvalidBlockError
end
end
|
ruby
|
{
"resource": ""
}
|
q5658
|
GameOverseer.Service.data_to_method
|
train
|
def data_to_method(data)
raise "No safe methods defined!" unless @safe_methods.size > 0
@safe_methods.each do |method|
if data['mode'] == method.to_s
self.send(data['mode'], data)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q5659
|
GameOverseer.Service.every
|
train
|
def every(milliseconds, &block)
Thread.new do
loop do
block.call
sleep(milliseconds/1000.0)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q5660
|
GameOverseer.Service.log
|
train
|
def log(string, color = Gosu::Color::RED)
GameOverseer::Console.log_with_color(string, color)
end
|
ruby
|
{
"resource": ""
}
|
q5661
|
ServerSentEvents.Event.to_s
|
train
|
def to_s
repr = ""
repr += "id: #{id}\n" if id
repr += "event: #{event}\n" if event
if data.empty?
repr += "data: \n"
else
data.split("\n").each { |l| repr += "data: #{l}\n" }
end
repr += "\n"
end
|
ruby
|
{
"resource": ""
}
|
q5662
|
ExecSandbox.Sandbox.push
|
train
|
def push(from, options = {})
to = File.join @path, (options[:to] || File.basename(from))
FileUtils.cp_r from, to
permissions = options[:read_only] ? 0770 : 0750
FileUtils.chmod_R permissions, to
FileUtils.chown_R @admin_uid, @user_gid, to
# NOTE: making a file / directory read-only is useless -- the sandboxed
# process can replace the file with another copy of the file; this can
# be worked around by noting the inode number of the protected file /
# dir, and making a hard link to it somewhere else so the inode won't
# be reused.
to
end
|
ruby
|
{
"resource": ""
}
|
q5663
|
ExecSandbox.Sandbox.pull
|
train
|
def pull(from, to)
from = File.join @path, from
return nil unless File.exist? from
FileUtils.cp_r from, to
FileUtils.chmod_R 0770, to
FileUtils.chown_R @admin_uid, @admin_gid, to
# NOTE: making a file / directory read-only is useless -- the sandboxed
# process can replace the file with another copy of the file; this can
# be worked around by noting the inode number of the protected file /
# dir, and making a hard link to it somewhere else so the inode won't
# be reused.
to
end
|
ruby
|
{
"resource": ""
}
|
q5664
|
ExecSandbox.Sandbox.run
|
train
|
def run(command, options = {})
limits = options[:limits] || {}
io = {}
if options[:in]
io[:in] = options[:in]
in_rd = nil
else
in_rd, in_wr = IO.pipe
in_wr.write options[:in_data] if options[:in_data]
in_wr.close
io[:in] = in_rd
end
if options[:out]
io[:out] = options[:out]
else
out_rd, out_wr = IO.pipe
io[:out] = out_wr
end
case options[:err]
when :out
io[:err] = STDOUT
when :none
# Don't set io[:err], so the child's stderr will be closed.
else
io[:err] = STDERR
end
pid = ExecSandbox::Spawn.spawn command, io, @principal, limits
# Close the pipe ends that are meant to be used in the child.
in_rd.close if in_rd
out_wr.close if out_wr
# Collect information about the child.
if out_rd
out_pieces = []
out_pieces << out_rd.read rescue nil
end
status = ExecSandbox::Wait4.wait4 pid
if out_rd
out_pieces << out_rd.read rescue nil
out_rd.close
status[:out_data] = out_pieces.join('')
end
status
end
|
ruby
|
{
"resource": ""
}
|
q5665
|
Scheduler.Model.ocurrences
|
train
|
def ocurrences(st, en = nil)
recurrence ?
recurrence.events(:starts => st, :until => en) :
(start_at.to_date..end_at.to_date).to_a
end
|
ruby
|
{
"resource": ""
}
|
q5666
|
RakeOE.Config.dump
|
train
|
def dump
puts '******************'
puts '* RakeOE::Config *'
puts '******************'
puts "Directories : #{@directories}"
puts "Suffixes : #{@suffixes}"
puts "Platform : #{@platform}"
puts "Release mode : #{@release}"
puts "Test framework : #{@test_fw}"
puts "Optimization dbg : #{@optimization_dbg}"
puts "Optimization release : #{@optimization_release}"
puts "Language Standard for C : #{@language_std_c}"
puts "Language Standard for C++ : #{@language_std_cpp}"
puts "Software version string : #{@sw_version}"
puts "Generate bin file : #{@generate_bin}"
puts "Generate hex file : #{@generate_hex}"
puts "Generate map file : #{@generate_map}"
puts "Strip objects : #{@stripped}"
end
|
ruby
|
{
"resource": ""
}
|
q5667
|
MinimalistAuthentication.User.authenticated?
|
train
|
def authenticated?(password)
if password_object == password
update_hash!(password) if password_object.stale?
return true
end
return false
end
|
ruby
|
{
"resource": ""
}
|
q5668
|
CircuitB.Fuse.open
|
train
|
def open
put(:state, :open)
if config[:on_break]
require 'timeout'
handlers = [ config[:on_break] ].flatten.map { |handler| (handler.is_a?(Symbol) ? STANDARD_HANDLERS[handler] : handler) }.compact
handlers.each do |handler|
begin
Timeout::timeout(@break_handler_timeout) {
handler.call(self)
}
rescue Timeout::Error
# We ignore handler timeouts
rescue
# We ignore handler errors
end
end
end
end
|
ruby
|
{
"resource": ""
}
|
q5669
|
CronSpec.CronSpecificationFactory.parse
|
train
|
def parse(value_spec)
case value_spec
when WildcardPattern
WildcardCronValue.new(@lower_limit, @upper_limit)
when @single_value_pattern
SingleValueCronValue.new(@lower_limit, @upper_limit, convert_value($1))
when @range_pattern
RangeCronValue.new(@lower_limit, @upper_limit, convert_value($1), convert_value($2))
when @step_pattern
StepCronValue.new(@lower_limit, @upper_limit, $1.to_i)
else
raise "Unrecognized cron specification pattern."
end
end
|
ruby
|
{
"resource": ""
}
|
q5670
|
RepoManager.ViewHelper.path_to
|
train
|
def path_to(*args)
case
when args.length == 1
base_path = :repo_manager
asset = args
when args.length == 2
base_path, asset = *args
when args.length > 2
raise ArgumentError, "Too many arguments"
else
raise ArgumentError, "Specify at least the file asset"
end
case base_path
when :repo_manager
root = File.expand_path('../../../../', __FILE__)
else
raise "unknown base_path"
end
File.join(root, asset)
end
|
ruby
|
{
"resource": ""
}
|
q5671
|
MongoidColoredLogger.LoggerDecorator.colorize_legacy_message
|
train
|
def colorize_legacy_message(message)
message.sub('MONGODB', color('MONGODB', odd? ? CYAN : MAGENTA)).
sub(%r{(?<=\[')([^']+)}) {|m| color(m, BLUE)}.
sub(%r{(?<=\]\.)\w+}) {|m| color(m, YELLOW)}
end
|
ruby
|
{
"resource": ""
}
|
q5672
|
MongoidColoredLogger.LoggerDecorator.colorize_message
|
train
|
def colorize_message(message)
message = message.sub('MONGODB', color('MONGODB', odd? ? CYAN : MAGENTA)).
sub(%r{(?<=\[')([^']+)}) {|m| color(m, BLUE)}.
sub(%r{(?<=\]\.)\w+}) {|m| color(m, YELLOW)}
message.sub('MOPED:', color('MOPED:', odd? ? CYAN : MAGENTA)).
sub(/\{.+?\}\s/) { |m| color(m, BLUE) }.
sub(/COMMAND|QUERY|KILL_CURSORS|INSERT|DELETE|UPDATE|GET_MORE|STARTED/) { |m| color(m, YELLOW) }.
sub(/SUCCEEDED/) { |m| color(m, GREEN) }.
sub(/FAILED/) { |m| color(m, RED) }.
sub(/[\d\.]+(s|ms)/) { |m| color(m, GREEN) }
end
|
ruby
|
{
"resource": ""
}
|
q5673
|
GBDispatch.Manager.get_queue
|
train
|
def get_queue(name=:default_queue)
name = name.to_sym
queue = @queues[name]
unless queue
@queues[name] = GBDispatch::Queue.new(name)
queue = @queues[name]
end
queue
end
|
ruby
|
{
"resource": ""
}
|
q5674
|
GBDispatch.Manager.run_async_on_queue
|
train
|
def run_async_on_queue(queue)
raise ArgumentError.new 'Queue must be GBDispatch::Queue' unless queue.is_a? GBDispatch::Queue
queue.async.perform_now ->() { yield }
end
|
ruby
|
{
"resource": ""
}
|
q5675
|
GBDispatch.Manager.run_sync_on_queue
|
train
|
def run_sync_on_queue(queue)
raise ArgumentError.new 'Queue must be GBDispatch::Queue' unless queue.is_a? GBDispatch::Queue
future = queue.await.perform_now ->() { yield }
future.value
end
|
ruby
|
{
"resource": ""
}
|
q5676
|
GBDispatch.Manager.run_after_on_queue
|
train
|
def run_after_on_queue(time, queue)
raise ArgumentError.new 'Queue must be GBDispatch::Queue' unless queue.is_a? GBDispatch::Queue
queue.perform_after time, ->(){ yield }
end
|
ruby
|
{
"resource": ""
}
|
q5677
|
Calligraphy.Utils.map_array_of_hashes
|
train
|
def map_array_of_hashes(arr_hashes)
return if arr_hashes.nil?
[].tap do |output_array|
arr_hashes.each do |hash|
output_array.push hash.values
end
end
end
|
ruby
|
{
"resource": ""
}
|
q5678
|
Calligraphy.Utils.extract_lock_token
|
train
|
def extract_lock_token(if_header)
token = if_header.scan(Calligraphy::LOCK_TOKEN_REGEX)
token.flatten.first if token.is_a? Array
end
|
ruby
|
{
"resource": ""
}
|
q5679
|
Cassie::Statements.Execution.execute
|
train
|
def execute(opts={})
@result = result_class.new(session.execute(statement, execution_options.merge(opts)), result_opts)
result.success?
end
|
ruby
|
{
"resource": ""
}
|
q5680
|
Cassie::Statements.Execution.execution_options
|
train
|
def execution_options
{}.tap do |opts|
# @todo rework consistency module to be more
# abstract implementation for all execution options
opts[:consistency] = consistency if consistency
opts[:paging_state] = paging_state if respond_to?(:paging_state) && paging_state
opts[:page_size] = stateless_page_size if respond_to?(:stateless_page_size) && stateless_page_size
end
end
|
ruby
|
{
"resource": ""
}
|
q5681
|
RepoManager.Add.save_writable_attributes
|
train
|
def save_writable_attributes(asset, attributes)
valid_keys = [:parent, :path]
accessable_attributes = {}
attributes.each do |key, value|
accessable_attributes[key] = value.dup if valid_keys.include?(key)
end
asset.configuration.save(accessable_attributes)
end
|
ruby
|
{
"resource": ""
}
|
q5682
|
EkmOmnimeter.Meter.method_missing
|
train
|
def method_missing(method_sym, *arguments, &block)
# Only refresh data if its more than 0.25 seconds old
et = @last_read_timestamp.nil? ? 0 : (Time.now - @last_read_timestamp)
@logger.debug "Elapsed time since last read #{et}"
if et > 250
@logger.info "More than 250 milliseconds have passed since last read. Triggering refresh."
read()
end
if @values.include? method_sym
@values[method_sym]
else
@logger.debug "method_missing failed to find #{method_sym} in the Meter.values cache"
super
end
end
|
ruby
|
{
"resource": ""
}
|
q5683
|
EkmOmnimeter.Meter.calculate_measurement
|
train
|
def calculate_measurement(m1, m2, m3)
if power_configuration == :single_phase_2wire
m1
elsif power_configuration == :single_phase_3wire
(m1 + m2)
elsif power_configuration == :three_phase_3wire
(m1 + m3)
elsif power_configuration == :three_phase_4wire
(m1 + m2 + m3)
end
end
|
ruby
|
{
"resource": ""
}
|
q5684
|
EkmOmnimeter.Meter.as_datetime
|
train
|
def as_datetime(s)
begin
d = DateTime.new("20#{s[0,2]}".to_i, s[2,2].to_i, s[4,2].to_i, s[8,2].to_i, s[10,2].to_i, s[12,2].to_i, '-4')
rescue
logger.error "Could not create valid datetime from #{s}\nDateTime.new(20#{s[0,2]}, #{s[2,2]}, #{s[4,2]}, #{s[8,2]}, #{s[10,2]}, #{s[12,2]}, '-4')"
d = DateTime.now()
end
d
end
|
ruby
|
{
"resource": ""
}
|
q5685
|
EkmOmnimeter.Meter.to_f_with_decimal_places
|
train
|
def to_f_with_decimal_places(s, p=1)
unless s.nil?
v = (s.to_f / (10 ** p))
logger.debug "Casting #{s.inspect} -> #{v.inspect}"
v
else
logger.error "Could not cast #{s} to #{p} decimal places"
end
end
|
ruby
|
{
"resource": ""
}
|
q5686
|
DocbookStatus.History.add
|
train
|
def add(ts, word_count)
# Ruby 1.8 doesn't have DateTime#to_date, so we check that here
begin
k = ts.to_date
rescue NoMethodError
k = Date.parse(ts.to_s)
end
if @history[:archive][k].nil?
@history[:archive][k] = { min: word_count, max: word_count, start: word_count, end: word_count, ctr: 1 }
else
@history[:archive][k][:min] = word_count if @history[:archive][k][:min] > word_count
@history[:archive][k][:max] = word_count if @history[:archive][k][:max] < word_count
@history[:archive][k][:end] = word_count
@history[:archive][k][:ctr] += 1
end
end
|
ruby
|
{
"resource": ""
}
|
q5687
|
FalkorLib.GitFlow.command
|
train
|
def command(name, type = 'feature', action = 'start', path = Dir.pwd, optional_args = '')
error "Invalid git-flow type '#{type}'" unless %w(feature release hotfix support).include?(type)
error "Invalid action '#{action}'" unless %w(start finish).include?(action)
error "You must provide a name" if name == ''
error "The name '#{name}' cannot contain spaces" if name =~ /\s+/
exit_status = 1
Dir.chdir( FalkorLib::Git.rootdir(path) ) do
exit_status = run %(
git flow #{type} #{action} #{optional_args} #{name}
)
end
exit_status
end
|
ruby
|
{
"resource": ""
}
|
q5688
|
FalkorLib.GitFlow.guess_gitflow_config
|
train
|
def guess_gitflow_config(dir = Dir.pwd, options = {})
path = normalized_path(dir)
use_git = FalkorLib::Git.init?(path)
return {} if (!use_git or !FalkorLib::GitFlow.init?(path))
rootdir = FalkorLib::Git.rootdir(path)
local_config = FalkorLib::Config.get(rootdir, :local)
return local_config[:gitflow] if local_config[:gitflow]
config = FalkorLib::Config::GitFlow::DEFAULTS.clone
[ :master, :develop ].each do |br|
config[:branches][br.to_sym] = FalkorLib::Git.config("gitflow.branch.#{br}", rootdir)
end
[ :feature, :release, :hotfix, :support, :versiontag ].each do |p|
config[:prefix][p.to_sym] = FalkorLib::Git.config("gitflow.prefix.#{p}", rootdir)
end
config
end
|
ruby
|
{
"resource": ""
}
|
q5689
|
JobmensaAssets.ImageProcessor.call
|
train
|
def call(file, *args, format: nil)
img = ::MiniMagick::Image.new(file.path)
img.quiet
img.format(format.to_s.downcase, nil) if format
send(@method, img, *args)
post_processing(img)
::File.open(img.path, "rb")
end
|
ruby
|
{
"resource": ""
}
|
q5690
|
JobmensaAssets.ImageProcessor.post_processing
|
train
|
def post_processing(img)
img.combine_options do |cmd|
cmd.strip # Deletes metatags
cmd.colorspace 'sRGB' # Change colorspace
cmd.auto_orient # Reset rotation
cmd.quiet # Suppress warnings
end
end
|
ruby
|
{
"resource": ""
}
|
q5691
|
Gares.Train.document
|
train
|
def document
if !@document
@document = Nokogiri::HTML(self.class.request_sncf(number, date))
if !itinerary_available?
@document = Nokogiri::HTML(self.class.request_sncf_itinerary(0))
end
end
if @document.at('#no_results')
fail TrainNotFound, @document.at('#no_results b').inner_html
end
@document
end
|
ruby
|
{
"resource": ""
}
|
q5692
|
Securities.Stock.generate_history_url
|
train
|
def generate_history_url
url = 'http://ichart.finance.yahoo.com/table.csv?s=%s&a=%s&b=%s&c=%s&d=%s&e=%s&f=%s&g=%s&ignore=.csv' % [
@symbol,
@start_date.to_date.month - 1,
@start_date.to_date.day,
@start_date.to_date.year,
@end_date.to_date.month - 1,
@end_date.to_date.day,
@end_date.to_date.year,
TYPE_CODES_ARRAY[@type]
]
return url
end
|
ruby
|
{
"resource": ""
}
|
q5693
|
Securities.Stock.validate_input
|
train
|
def validate_input parameters
unless parameters.is_a?(Hash)
raise StockException, 'Given parameters have to be a hash.'
end
# Check if stock symbol is specified.
unless parameters.has_key?(:symbol)
raise StockException, 'No stock symbol specified.'
end
# Check if stock symbol is a string.
unless parameters[:symbol].is_a?(String)
raise StockException, 'Stock symbol must be a string.'
end
# Use today date if :end_date is not specified.
unless parameters.has_key?(:end_date)
parameters[:end_date] = Date.today.strftime("%Y-%m-%d")
end
unless parameters.has_key?(:start_date)
raise StockException, 'Start date must be specified.'
end
unless DATE_REGEX.match(parameters[:start_date])
raise StockException, 'Invalid start date specified. Format YYYY-MM-DD.'
end
unless DATE_REGEX.match(parameters[:end_date])
raise StockException, 'Invalid end date specified. Format YYYY-MM-DD.'
end
unless parameters[:start_date].to_date < parameters[:end_date].to_date
raise StockException, 'End date must be greater than the start date.'
end
unless parameters[:start_date].to_date < Date.today
raise StockException, 'Start date must not be in the future.'
end
# Set to default :type if key isn't specified.
parameters[:type] = :daily if !parameters.has_key?(:type)
unless TYPE_CODES_ARRAY.has_key?(parameters[:type])
raise StockException, 'Invalid type specified.'
end
end
|
ruby
|
{
"resource": ""
}
|
q5694
|
Praxis.Renderer.render_collection
|
train
|
def render_collection(collection, member_fields, view = nil, context: Attributor::DEFAULT_ROOT_CONTEXT)
render(collection, [member_fields], view, context: context)
end
|
ruby
|
{
"resource": ""
}
|
q5695
|
Praxis.Renderer.render
|
train
|
def render(object, fields, view = nil, context: Attributor::DEFAULT_ROOT_CONTEXT)
if fields.is_a? Array
sub_fields = fields[0]
object.each_with_index.collect do |sub_object, i|
sub_context = context + ["at(#{i})"]
render(sub_object, sub_fields, view, context: sub_context)
end
elsif object.is_a? Praxis::Blueprint
@cache[object.object_id][fields.object_id] ||= _render(object, fields, view, context: context)
else
_render(object, fields, view, context: context)
end
rescue SystemStackError
raise CircularRenderingError.new(object, context)
end
|
ruby
|
{
"resource": ""
}
|
q5696
|
Opee.Log.log
|
train
|
def log(severity, message, tid)
now = Time.now
ss = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL'][severity]
ss = '' if ss.nil?
if @formatter.nil?
msg = "#{ss[0]}, [#{now.strftime('%Y-%m-%dT%H:%M:%S.%6N')} ##{tid}] #{ss} -- : #{message}\n"
else
msg = @formatter.call(ss, now, tid, message)
end
@logger.add(severity, msg)
@forward.log(severity, message, tid) unless @forward.nil?
end
|
ruby
|
{
"resource": ""
}
|
q5697
|
Opee.Log.stream=
|
train
|
def stream=(stream)
logger = Logger.new(stream)
logger.level = @logger.level
logger.formatter = @logger.formatter
@logger = logger
end
|
ruby
|
{
"resource": ""
}
|
q5698
|
Opee.Log.set_filename
|
train
|
def set_filename(filename, shift_age=7, shift_size=1048576)
logger = Logger.new(filename, shift_age, shift_size)
logger.level = @logger.level
logger.formatter = @logger.formatter
@logger = logger
end
|
ruby
|
{
"resource": ""
}
|
q5699
|
Opee.Log.severity=
|
train
|
def severity=(level)
if level.is_a?(String)
severity = {
'FATAL' => Logger::Severity::FATAL,
'ERROR' => Logger::Severity::ERROR,
'WARN' => Logger::Severity::WARN,
'INFO' => Logger::Severity::INFO,
'DEBUG' => Logger::Severity::DEBUG,
'4' => Logger::Severity::FATAL,
'3' => Logger::Severity::ERROR,
'2' => Logger::Severity::WARN,
'1' => Logger::Severity::INFO,
'0' => Logger::Severity::DEBUG
}[level.upcase()]
raise "#{level} is not a severity" if severity.nil?
level = severity
elsif level < Logger::Severity::DEBUG || Logger::Severity::FATAL < level
raise "#{level} is not a severity"
end
@logger.level = level
end
|
ruby
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.