_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3 values | text stringlengths 66 10.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q15500 | Strings.Pad.pad_around | train | def pad_around(text, padding, fill: SPACE)
fill * padding.left + text + fill * padding.right
end | ruby | {
"resource": ""
} |
q15501 | Strings.Align.align_left | train | def align_left(text, width, fill: SPACE, separator: NEWLINE)
return if width.nil?
each_line(text, separator) do |line|
width_diff = width - display_width(line)
if width_diff > 0
line + fill * width_diff
else
line
end
end
end | ruby | {
"resource": ""
} |
q15502 | Strings.Align.align_center | train | def align_center(text, width, fill: SPACE, separator: NEWLINE)
return text if width.nil?
each_line(text, separator) do |line|
width_diff = width - display_width(line)
if width_diff > 0
right_count = (width_diff.to_f / 2).ceil
left_count = width_diff - right_count
[fill * left_count, line, fill * right_count].join
else
line
end
end
end | ruby | {
"resource": ""
} |
q15503 | Strings.Align.each_line | train | def each_line(text, separator)
lines = text.split(separator)
return yield(text) if text.empty?
lines.reduce([]) do |aligned, line|
aligned << yield(line)
end.join(separator)
end | ruby | {
"resource": ""
} |
q15504 | Nylas.HttpClient.execute | train | def execute(method:, path: nil, headers: {}, query: {}, payload: nil)
timeout = ENDPOINT_TIMEOUTS.fetch(path, 230)
request = build_request(
method: method,
path: path,
headers: headers,
query: query,
payload: payload,
timeout: timeout
)
rest_client_execute(**request) do |response, _request, result|
response = parse_response(response)
handle_failed_response(result: result, response: response)
response
end
end | ruby | {
"resource": ""
} |
q15505 | Nylas.HttpClient.get | train | def get(path: nil, headers: {}, query: {})
execute(method: :get, path: path, query: query, headers: headers)
end | ruby | {
"resource": ""
} |
q15506 | Nylas.HttpClient.post | train | def post(path: nil, payload: nil, headers: {}, query: {})
execute(method: :post, path: path, headers: headers, query: query, payload: payload)
end | ruby | {
"resource": ""
} |
q15507 | Nylas.HttpClient.put | train | def put(path: nil, payload:, headers: {}, query: {})
execute(method: :put, path: path, headers: headers, query: query, payload: payload)
end | ruby | {
"resource": ""
} |
q15508 | Nylas.HttpClient.delete | train | def delete(path: nil, payload: nil, headers: {}, query: {})
execute(method: :delete, path: path, headers: headers, query: query, payload: payload)
end | ruby | {
"resource": ""
} |
q15509 | Nylas.Collection.where | train | def where(filters)
raise ModelNotFilterableError, model unless model.filterable?
self.class.new(model: model, api: api, constraints: constraints.merge(where: filters))
end | ruby | {
"resource": ""
} |
q15510 | Nylas.Collection.raw | train | def raw
raise ModelNotAvailableAsRawError, model unless model.exposable_as_raw?
self.class.new(model: model, api: api, constraints: constraints.merge(accept: model.raw_mime_type))
end | ruby | {
"resource": ""
} |
q15511 | Nylas.Collection.each | train | def each
return enum_for(:each) unless block_given?
execute.each do |result|
yield(model.new(result.merge(api: api)))
end
end | ruby | {
"resource": ""
} |
q15512 | Nylas.Collection.find_each | train | def find_each
return enum_for(:find_each) unless block_given?
query = self
accumulated = 0
while query
results = query.each do |instance|
yield(instance)
end
accumulated += results.length
query = query.next_page(accumulated: accumulated, current_page: results)
end
end | ruby | {
"resource": ""
} |
q15513 | Nylas.File.download! | train | def download!
return download if file.nil?
file.close
file.unlink
self.file = nil
download
end | ruby | {
"resource": ""
} |
q15514 | Nylas.API.revoke | train | def revoke(access_token)
response = client.as(access_token).post(path: "/oauth/revoke")
response.code == 200 && response.empty?
end | ruby | {
"resource": ""
} |
q15515 | FoodCritic.CommandLine.valid_paths? | train | def valid_paths?
paths = options[:cookbook_paths] + options[:role_paths] +
options[:environment_paths]
paths.any? && paths.all? { |path| File.exist?(path) }
end | ruby | {
"resource": ""
} |
q15516 | FoodCritic.CommandLine.valid_grammar? | train | def valid_grammar?
return true unless options.key?(:search_grammar)
return false unless File.exist?(options[:search_grammar])
search = FoodCritic::Chef::Search.new
search.create_parser([options[:search_grammar]])
search.parser?
end | ruby | {
"resource": ""
} |
q15517 | FoodCritic.Linter.list | train | def list(options = {})
options = setup_defaults(options)
@options = options
load_rules
if options[:tags].any?
@rules = active_rules(options[:tags])
end
RuleList.new(@rules)
end | ruby | {
"resource": ""
} |
q15518 | FoodCritic.Linter.check | train | def check(options = {})
options = setup_defaults(options)
@options = options
@chef_version = options[:chef_version] || DEFAULT_CHEF_VERSION
warnings = []; last_dir = nil; matched_rule_tags = Set.new
load_rules
paths = specified_paths!(options)
# Loop through each file to be processed and apply the rules
files = files_to_process(paths)
if options[:progress]
puts "Checking #{files.count} files"
end
files.each do |p|
relevant_tags = if options[:tags].any?
options[:tags]
else
rule_file_tags(p[:filename])
end
progress = "."
active_rules(relevant_tags).each do |rule|
state = {
path_type: p[:path_type],
file: p[:filename],
ast: read_ast(p[:filename]),
rule: rule,
last_dir: last_dir,
}
matches = if p[:path_type] == :cookbook
cookbook_matches(state)
else
other_matches(state)
end
matches = remove_ignored(matches, state[:rule], state[:file])
progress = "x" if matches.any?
# Convert the matches into warnings
matches.each do |match|
warnings << Warning.new(state[:rule],
{ filename: state[:file] }.merge(match),
options)
matched_rule_tags << state[:rule].tags
end
end
putc progress if options[:progress]
last_dir = cookbook_dir(p[:filename])
end
puts "" if options[:progress]
Review.new(paths, warnings)
end | ruby | {
"resource": ""
} |
q15519 | FoodCritic.Linter.applies_to_version? | train | def applies_to_version?(rule, version)
return true unless version
rule.applies_to.yield(Gem::Version.create(version))
end | ruby | {
"resource": ""
} |
q15520 | FoodCritic.Linter.rule_file_tags | train | def rule_file_tags(file)
cookbook = cookbook_dir(file)
@tag_cache ||= {}
# lookup the tags in the cache has and return that if we find something
cb_tags = @tag_cache[cookbook]
return cb_tags unless cb_tags.nil?
# if a rule file has been specified use that. Otherwise use the .foodcritic file in the CB
tags = if @options[:rule_file]
raise "ERROR: Could not find the specified rule file at #{@options[:rule_file]}" unless File.exist?(@options[:rule_file])
parse_rule_file(@options[:rule_file])
else
File.exist?("#{cookbook}/.foodcritic") ? parse_rule_file("#{cookbook}/.foodcritic") : []
end
@tag_cache[cookbook] = tags
tags
end | ruby | {
"resource": ""
} |
q15521 | FoodCritic.Linter.parse_rule_file | train | def parse_rule_file(file)
tags = []
begin
tag_text = File.read file
tags = tag_text.split(/\s/)
rescue
raise "ERROR: Could not read or parse the specified rule file at #{file}"
end
tags
end | ruby | {
"resource": ""
} |
q15522 | FoodCritic.Linter.cookbook_dir | train | def cookbook_dir(file)
@dir_cache ||= {}
abs_file = File.absolute_path(file)
# lookup the file in the cache has and return that if we find something
cook_val = @dir_cache[abs_file]
return cook_val unless cook_val.nil?
if file =~ /\.erb$/
# split each directory into an item in the array
dir_array = File.dirname(file).split(File::SEPARATOR)
# walk through the array of directories backwards until we hit the templates directory
position = -1
position -= 1 until dir_array[position] == "templates"
# go back 1 more position to get to the cookbook dir
position -= 1
# slice from the start to the cookbook dir and then join it all back to a string
cook_val = dir_array.slice(0..position).join(File::SEPARATOR)
else
# determine the difference to the root of the CB from our file's directory
relative_difference = case File.basename(file)
when "recipe.rb", "attributes.rb", "metadata.rb" then ""
else # everything else is 1 directory up ie. cookbook/recipes/default.rb
".."
end
cook_val = Pathname.new(File.join(File.dirname(file), relative_difference)).cleanpath
end
@dir_cache[abs_file] = cook_val
cook_val
end | ruby | {
"resource": ""
} |
q15523 | FoodCritic.Linter.files_to_process | train | def files_to_process(paths)
paths.reject { |type, _| type == :exclude }.map do |path_type, dirs|
dirs.map do |dir|
exclusions = []
unless paths[:exclude].empty?
exclusions = Dir.glob(paths[:exclude].map do |p|
File.join(dir, p, "**/**")
end)
end
if File.directory?(dir)
glob = if path_type == :cookbook
"{metadata.rb,attributes.rb,recipe.rb,{attributes,definitions,libraries,"\
"providers,recipes,resources}/*.rb,templates/**/*.erb}"
else
"*.rb"
end
(Dir.glob(File.join(dir, glob)) +
Dir.glob(File.join(dir, "*/#{glob}")) - exclusions)
else
dir unless exclusions.include?(dir)
end
end.compact.flatten.map do |filename|
{ filename: filename, path_type: path_type }
end
end.flatten
end | ruby | {
"resource": ""
} |
q15524 | FoodCritic.Linter.matches | train | def matches(match_method, *params)
return [] unless match_method.respond_to?(:yield)
matches = match_method.yield(*params)
return [] unless matches.respond_to?(:each)
# We convert Nokogiri nodes to matches transparently
matches.map do |m|
if m.respond_to?(:node_name)
match(m)
elsif m.respond_to?(:xpath)
m.to_a.map { |n| match(n) }
else
m
end
end.flatten
end | ruby | {
"resource": ""
} |
q15525 | FoodCritic.Chef.valid_query? | train | def valid_query?(query)
raise ArgumentError, "Query cannot be nil or empty" if query.to_s.empty?
# Attempt to create a search query parser
search = FoodCritic::Chef::Search.new
search.create_parser(search.chef_search_grammars)
if search.parser?
search.parser.parse(query.to_s)
else
# If we didn't manage to get a parser then we can't know if the query
# is valid or not.
true
end
end | ruby | {
"resource": ""
} |
q15526 | FoodCritic.Chef.load_metadata | train | def load_metadata
version = if respond_to?(:chef_version)
chef_version
else
Linter::DEFAULT_CHEF_VERSION
end
metadata_path = [version, version.sub(/\.[a-z].*/, ""),
Linter::DEFAULT_CHEF_VERSION].map do |ver|
metadata_path(ver)
end.find { |m| File.exist?(m) }
@dsl_metadata ||= FFI_Yajl::Parser.parse(IO.read(metadata_path),
symbolize_keys: true)
end | ruby | {
"resource": ""
} |
q15527 | FoodCritic.ContextOutput.output | train | def output(review)
unless review.respond_to?(:warnings)
puts review; return
end
context = 3
print_fn = lambda { |fn| ansi_print(fn, :red, nil, :bold) }
print_rule = lambda { |warn| ansi_print(warn, :cyan, nil, :bold) }
print_line = lambda { |line| ansi_print(line, nil, :red, :bold) }
key_by_file_and_line(review).each do |fn, warnings|
print_fn.call fn
unless File.exist?(fn)
print_rule.call warnings[1].to_a.join("\n")
next
end
# Set of line numbers with warnings
warn_lines = warnings.keys.to_set
# Moving set of line numbers within the context of our position
context_set = (0..context).to_set
# The last line number we printed a warning for
last_warn = -1
File.open(fn) do |file|
file.each do |line|
context_set.add(file.lineno + context)
context_set.delete(file.lineno - context - 1)
# Find the first warning within our context
context_warns = context_set & warn_lines
next_warn = context_warns.min
# We may need to interrupt the trailing context
# of a previous warning
next_warn = file.lineno if warn_lines.include? file.lineno
# Display a warning
if next_warn && next_warn > last_warn
print_rule.call warnings[next_warn].to_a.join("\n")
last_warn = next_warn
end
# Display any relevant lines
if warn_lines.include? file.lineno
print "%4i|" % file.lineno
print_line.call line.chomp
elsif not context_warns.empty?
print "%4i|" % file.lineno
puts line.chomp
end
end
end
end
end | ruby | {
"resource": ""
} |
q15528 | FoodCritic.ContextOutput.key_by_file_and_line | train | def key_by_file_and_line(review)
warn_hash = {}
review.warnings.each do |warning|
filename = Pathname.new(warning.match[:filename]).cleanpath.to_s
line_num = warning.match[:line].to_i
warn_hash[filename] = {} unless warn_hash.key?(filename)
unless warn_hash[filename].key?(line_num)
warn_hash[filename][line_num] = Set.new
end
warn_hash[filename][line_num] << warning.rule
end
warn_hash
end | ruby | {
"resource": ""
} |
q15529 | FoodCritic.Api.ensure_file_exists | train | def ensure_file_exists(basepath, filepath)
path = File.join(basepath, filepath)
[file_match(path)] unless File.exist?(path)
end | ruby | {
"resource": ""
} |
q15530 | FoodCritic.Api.attribute_access | train | def attribute_access(ast, options = {})
options = { type: :any, ignore_calls: false }.merge!(options)
return [] unless ast.respond_to?(:xpath)
unless [:any, :string, :symbol, :vivified].include?(options[:type])
raise ArgumentError, "Node type not recognised"
end
case options[:type]
when :any then
vivified_attribute_access(ast, options) +
standard_attribute_access(ast, options)
when :vivified then
vivified_attribute_access(ast, options)
else
standard_attribute_access(ast, options)
end
end | ruby | {
"resource": ""
} |
q15531 | FoodCritic.Api.cookbook_base_path | train | def cookbook_base_path(file)
file = File.expand_path(file) # make sure we get an absolute path
file = File.dirname(file) unless File.directory?(file) # get the dir only
# get list of items in the dir and intersect with metadata array.
# until we get an interfact (we have a metadata) walk up the dir structure
until (Dir.entries(file) & %w{metadata.rb metadata.json}).any?
file = File.dirname(file)
end
file
end | ruby | {
"resource": ""
} |
q15532 | FoodCritic.Api.metadata_field | train | def metadata_field(file, field)
until (file.split(File::SEPARATOR) & standard_cookbook_subdirs).empty?
file = File.absolute_path(File.dirname(file.to_s))
end
file = File.dirname(file) unless File.extname(file).empty?
md_path = File.join(file, "metadata.rb")
if File.exist?(md_path)
value = read_ast(md_path).xpath("//stmts_add/
command[ident/@value='#{field}']/
descendant::tstring_content/@value").to_s
raise "Cant read #{field} from #{md_path}" if value.to_s.empty?
return value
else
raise "Cant find #{md_path}"
end
end | ruby | {
"resource": ""
} |
q15533 | FoodCritic.Api.cookbook_name | train | def cookbook_name(file)
raise ArgumentError, "File cannot be nil or empty" if file.to_s.empty?
# Name is a special case as we want to fallback to the cookbook directory
# name if metadata_field fails
begin
metadata_field(file, "name")
rescue RuntimeError
until (file.split(File::SEPARATOR) & standard_cookbook_subdirs).empty?
file = File.absolute_path(File.dirname(file.to_s))
end
file = File.dirname(file) unless File.extname(file).empty?
File.basename(file)
end
end | ruby | {
"resource": ""
} |
q15534 | FoodCritic.Api.declared_dependencies | train | def declared_dependencies(ast)
raise_unless_xpath!(ast)
deps = []
# String literals.
#
# depends 'foo'
deps += field(ast, "depends").xpath("descendant::args_add/descendant::tstring_content[1]")
# Quoted word arrays are also common.
#
# %w{foo bar baz}.each do |cbk|
# depends cbk
# end
deps += word_list_values(field(ast, "depends"))
deps.uniq!
deps.map! { |dep| dep["value"].strip }
deps
end | ruby | {
"resource": ""
} |
q15535 | FoodCritic.Api.field | train | def field(ast, field_name)
if field_name.nil? || field_name.to_s.empty?
raise ArgumentError, "Field name cannot be nil or empty"
end
ast.xpath("(.//command[ident/@value='#{field_name}']|.//fcall[ident/@value='#{field_name}']/..)")
end | ruby | {
"resource": ""
} |
q15536 | FoodCritic.Api.field_value | train | def field_value(ast, field_name)
field(ast, field_name).xpath('.//args_add_block//tstring_content
[count(ancestor::args_add) = 1][count(ancestor::string_add) = 1]
/@value').map { |a| a.to_s }.last
end | ruby | {
"resource": ""
} |
q15537 | FoodCritic.Api.file_match | train | def file_match(file)
raise ArgumentError, "Filename cannot be nil" if file.nil?
{ filename: file, matched: file, line: 1, column: 1 }
end | ruby | {
"resource": ""
} |
q15538 | FoodCritic.Api.included_recipes | train | def included_recipes(ast, options = { with_partial_names: true })
raise_unless_xpath!(ast)
filter = ["[count(descendant::args_add) = 1]"]
# If `:with_partial_names` is false then we won't include the string
# literal portions of any string that has an embedded expression.
unless options[:with_partial_names]
filter << "[count(descendant::string_embexpr) = 0]"
end
string_desc = '[descendant::args_add/string_literal]/
descendant::tstring_content'
included = ast.xpath([
"//command[ident/@value = 'include_recipe']",
"//fcall[ident/@value = 'include_recipe']/
following-sibling::arg_paren",
].map do |recipe_include|
recipe_include + filter.join + string_desc
end.join(" | "))
# Hash keyed by recipe name with matched nodes.
included.inject(Hash.new([])) { |h, i| h[i["value"]] += [i]; h }
end | ruby | {
"resource": ""
} |
q15539 | FoodCritic.Api.match | train | def match(node)
raise_unless_xpath!(node)
pos = node.xpath("descendant::pos").first
return nil if pos.nil?
{ matched: node.respond_to?(:name) ? node.name : "",
line: pos["line"].to_i, column: pos["column"].to_i }
end | ruby | {
"resource": ""
} |
q15540 | FoodCritic.Api.read_ast | train | def read_ast(file)
@ast_cache ||= Rufus::Lru::Hash.new(5)
if @ast_cache.include?(file)
@ast_cache[file]
else
@ast_cache[file] = uncached_read_ast(file)
end
end | ruby | {
"resource": ""
} |
q15541 | FoodCritic.Api.resource_attribute | train | def resource_attribute(resource, name)
raise ArgumentError, "Attribute name cannot be empty" if name.empty?
resource_attributes(resource)[name.to_s]
end | ruby | {
"resource": ""
} |
q15542 | FoodCritic.Api.resource_attributes | train | def resource_attributes(resource, options = {})
atts = {}
name = resource_name(resource, options)
atts[:name] = name unless name.empty?
atts.merge!(normal_attributes(resource, options))
atts.merge!(block_attributes(resource))
atts
end | ruby | {
"resource": ""
} |
q15543 | FoodCritic.Api.resource_attributes_by_type | train | def resource_attributes_by_type(ast)
result = {}
resources_by_type(ast).each do |type, resources|
result[type] = resources.map do |resource|
resource_attributes(resource)
end
end
result
end | ruby | {
"resource": ""
} |
q15544 | FoodCritic.Api.resource_name | train | def resource_name(resource, options = {})
raise_unless_xpath!(resource)
options = { return_expressions: false }.merge(options)
if options[:return_expressions]
name = resource.xpath("command/args_add_block")
if name.xpath("descendant::string_add").size == 1 &&
name.xpath("descendant::string_literal").size == 1 &&
name.xpath(
"descendant::*[self::call or self::string_embexpr]").empty?
name.xpath("descendant::tstring_content/@value").to_s
else
name
end
else
# Preserve existing behaviour
resource.xpath("string(command//tstring_content/@value)")
end
end | ruby | {
"resource": ""
} |
q15545 | FoodCritic.Api.resources_by_type | train | def resources_by_type(ast)
raise_unless_xpath!(ast)
result = Hash.new { |hash, key| hash[key] = Array.new }
find_resources(ast).each do |resource|
result[resource_type(resource)] << resource
end
result
end | ruby | {
"resource": ""
} |
q15546 | FoodCritic.Api.ruby_code? | train | def ruby_code?(str)
str = str.to_s
return false if str.empty?
checker = FoodCritic::ErrorChecker.new(str)
checker.parse
!checker.error?
end | ruby | {
"resource": ""
} |
q15547 | FoodCritic.Api.supported_platforms | train | def supported_platforms(ast)
# Find the supports() method call.
platforms_ast = field(ast, "supports")
# Look for the first argument (the node next to the top args_new) and
# filter out anything with a string_embexpr since that can't be parsed
# statically. Then grab the static value for both strings and symbols, and
# finally combine it with the word list (%w{}) analyzer.
platforms = platforms_ast.xpath("(.//args_new)[1]/../*[not(.//string_embexpr)]").xpath(".//tstring_content|.//symbol/ident") | word_list_values(platforms_ast)
platforms.map do |platform|
# For each platform value, look for all arguments after the first, then
# extract the string literal value.
versions = platform.xpath("ancestor::args_add[not(args_new)]/*[position()=2]//tstring_content/@value")
{ platform: platform["value"].lstrip, versions: versions.map(&:to_s) }
end.sort_by { |p| p[:platform] }
end | ruby | {
"resource": ""
} |
q15548 | FoodCritic.Api.template_paths | train | def template_paths(recipe_path)
Dir.glob(Pathname.new(recipe_path).dirname.dirname + "templates" +
"**/*", File::FNM_DOTMATCH).select do |path|
File.file?(path)
end.reject do |path|
File.basename(path) == ".DS_Store" || File.extname(path) == ".swp"
end
end | ruby | {
"resource": ""
} |
q15549 | FoodCritic.Api.json_file_to_hash | train | def json_file_to_hash(filename)
raise "File #{filename} not found" unless File.exist?(filename)
file = File.read(filename)
begin
FFI_Yajl::Parser.parse(file)
rescue FFI_Yajl::ParseError
raise "File #{filename} does not appear to contain valid JSON"
end
end | ruby | {
"resource": ""
} |
q15550 | FoodCritic.Api.build_xml | train | def build_xml(node, doc = nil, xml_node = nil)
doc, xml_node = xml_document(doc, xml_node)
if node.respond_to?(:each)
node.each do |child|
if position_node?(child)
xml_position_node(doc, xml_node, child)
else
if ast_node_has_children?(child)
# The AST structure is different for hashes so we have to treat
# them separately.
if ast_hash_node?(child)
xml_hash_node(doc, xml_node, child)
else
xml_array_node(doc, xml_node, child)
end
else
xml_node["value"] = child.to_s unless child.nil?
end
end
end
end
xml_node
end | ruby | {
"resource": ""
} |
q15551 | FoodCritic.Api.node_method? | train | def node_method?(meth, cookbook_dir)
chef_dsl_methods.include?(meth) || meth == :set || meth == :set_unless ||
patched_node_method?(meth, cookbook_dir)
end | ruby | {
"resource": ""
} |
q15552 | FoodCritic.CommandHelpers.expect_warning | train | def expect_warning(code, options = {})
if options.has_key?(:file_type)
options[:file] = { :attributes => "attributes/default.rb", :definition => "definitions/apache_site.rb",
:metadata => "metadata.rb", :provider => "providers/site.rb",
:resource => "resources/site.rb", :libraries => "libraries/lib.rb" }[options[:file_type]]
end
options = { :line => 1, :expect_warning => true, :file => "recipes/default.rb" }.merge!(options)
unless options[:file].include?("roles") ||
options[:file].include?("environments")
options[:file] = "cookbooks/example/#{options[:file]}"
end
if options[:warning_only]
warning = "#{code}: #{WARNINGS[code]}"
else
warning = "#{code}: #{WARNINGS[code]}: #{options[:file]}:#{options[:line]}#{"\n" if ! options[:line].nil?}"
end
options[:expect_warning] ? expect_output(warning) : expect_no_output(warning)
end | ruby | {
"resource": ""
} |
q15553 | FoodCritic.CommandHelpers.usage_displayed | train | def usage_displayed(is_exit_zero)
expect_output "foodcritic [cookbook_paths]"
usage_options.each do |option|
expect_usage_option(option[:short], option[:long], option[:description])
end
if is_exit_zero
assert_no_error_occurred
else
assert_error_occurred
end
end | ruby | {
"resource": ""
} |
q15554 | FoodCritic.InProcessHelpers.run_lint | train | def run_lint(cmd_args)
cd "." do
show_context = cmd_args.include?("-C")
review, @status = FoodCritic::Linter.run(CommandLine.new(cmd_args))
@review =
if review.nil? || (review.respond_to?(:warnings) && review.warnings.empty?)
""
elsif show_context
ContextOutput.new.output(review)
else
"#{review}\n"
end
end
end | ruby | {
"resource": ""
} |
q15555 | FoodCritic.BuildHelpers.assert_build_result | train | def assert_build_result(success, warnings)
success ? assert_no_error_occurred : assert_error_occurred
warnings.each do |code|
expect_warning(code, :warning_only => true)
end
end | ruby | {
"resource": ""
} |
q15556 | FoodCritic.BuildHelpers.build_tasks | train | def build_tasks
all_output.split("\n").map do |task|
next unless task.start_with? "rake"
task.split("#").map { |t| t.strip.sub(/^rake /, "") }
end.compact
end | ruby | {
"resource": ""
} |
q15557 | FoodCritic.ArubaHelpers.expect_output | train | def expect_output(output)
if output.respond_to?(:~)
assert_matching_output(output.to_s, all_output)
else
assert_partial_output(output, all_output)
end
end | ruby | {
"resource": ""
} |
q15558 | FoodCritic.Notifications.notifications | train | def notifications(ast)
# Sanity check the AST provided.
return [] unless ast.respond_to?(:xpath)
# We are mapping each `notifies` or `subscribes` line in the provided
# AST to a Hash with the extracted details.
notification_nodes(ast).map do |notify|
# Chef supports two styles of notification.
notified_resource = if new_style_notification?(notify)
# `notifies :restart, "service[foo]"`
new_style_notification(notify)
else
# `notifies :restart, resources(service: "foo")`
old_style_notification(notify)
end
# Ignore if the notification was not parsed
next unless notified_resource
# Now merge the extract notification details with the attributes
# that are common to both styles of notification.
notified_resource.merge(
{
# The `:type` of notification: `:subscribes` or `:notifies`.
type: notification_type(notify),
# The `:style` of notification: `:new` or `:old`.
style: new_style_notification?(notify) ? :new : :old,
# The target resource action.
action: notification_action(notify),
# The notification timing: `:before`, `:immediate` or `:delayed`.
timing: notification_timing(notify),
}
)
end.compact
end | ruby | {
"resource": ""
} |
q15559 | FoodCritic.Notifications.notification_action | train | def notification_action(notify)
is_variable = true unless notify.xpath("args_add_block/args_add//args_add[aref or vcall or call or var_ref]").empty?
string_val = notify.xpath("descendant::args_add/string_literal/string_add/tstring_content/@value").first
symbol_val = notify.xpath('descendant::args_add/args_add//symbol/ident/@value |
descendant::dyna_symbol[1]/xstring_add/tstring_content/@value').first
# 1) return a nil if the action is a variable like node['foo']['bar']
# 2) return the symbol if it exists
# 3) return the string since we're positive that we're not a symbol or variable
return nil if is_variable
return symbol_val.value.to_sym unless symbol_val.nil?
string_val.value
end | ruby | {
"resource": ""
} |
q15560 | FoodCritic.CookbookHelpers.cookbook_that_matches_rules | train | def cookbook_that_matches_rules(codes)
recipe = ""
codes.each do |code|
if code == "FC002"
recipe += %q{
directory "#{node['base_dir']}" do
action :create
end
}
elsif code == "FC004"
recipe += %q{
execute "stop-jetty" do
command "/etc/init.d/jetty6 stop"
action :run
end
}
elsif code == "FC005"
recipe += %q{
package 'erlang-base' do
action :upgrade
end
package 'erlang-corba' do
action :upgrade
end
package 'erlang-another' do
action :upgrade
end
}
elsif code == "FC006"
recipe += %q{
directory "/var/lib/foo" do
mode 644
action :create
end
}
end
end
write_recipe(recipe)
write_file("cookbooks/example/recipes/server.rb", "")
write_readme("Hello World") # Don't trigger FC011
write_metadata(%q{
name 'example'
maintainer 'A Maintainer'
maintainer_email 'maintainer@example.com'
version '0.0.1'
issues_url 'http://github.com/foo/bar_cookbook/issues'
source_url 'http://github.com/foo/bar_cookbook'
}.strip)
end | ruby | {
"resource": ""
} |
q15561 | FoodCritic.CookbookHelpers.cookbook_with_lwrp | train | def cookbook_with_lwrp(lwrp)
lwrp = { :default_action => false, :notifies => :does_not_notify,
:use_inline_resources => false }.merge!(lwrp)
ruby_default_action = %q{
def initialize(*args)
super
@action = :create
end
}.strip
write_resource("site", %Q{
actions :create
attribute :name, :kind_of => String, :name_attribute => true
#{ruby_default_action if lwrp[:default_action] == :ruby_default_action}
#{'default_action :create' if lwrp[:default_action] == :dsl_default_action}
})
notifications = { :does_notify => "new_resource.updated_by_last_action(true)",
:does_notify_without_parens => "new_resource.updated_by_last_action true",
:deprecated_syntax => "new_resource.updated = true",
:class_variable => "@updated = true" }
write_provider("site", %Q{
#{'use_inline_resources' if lwrp[:use_inline_resources]}
action :create do
log "Here is where I would create a site"
#{notifications[lwrp[:notifies]]}
end
})
end | ruby | {
"resource": ""
} |
q15562 | FoodCritic.CookbookHelpers.cookbook_with_maintainer | train | def cookbook_with_maintainer(name, email)
write_recipe %q{
#
# Cookbook Name:: example
# Recipe:: default
#
# Copyright 2011, YOUR_COMPANY_NAME
#
# All rights reserved - Do Not Redistribute
#
}
fields = {}
fields["maintainer"] = name unless name.nil?
fields["maintainer_email"] = email unless email.nil?
write_metadata %Q{
#{fields.map { |field, value| %Q{#{field}\t"#{value}"} }.join("\n")}
license "All rights reserved"
description "Installs/Configures example"
long_description IO.read(File.join(File.dirname(__FILE__), 'README.rdoc'))
version "0.0.1"
}
end | ruby | {
"resource": ""
} |
q15563 | FoodCritic.CookbookHelpers.rakefile | train | def rakefile(task, options)
rakefile_content = "task :default => []"
task_def = case task
when :no_block then "FoodCritic::Rake::LintTask.new"
else %Q{
FoodCritic::Rake::LintTask.new do |t|
#{"t.name = '#{options[:name]}'" if options[:name]}
#{"t.files = #{options[:files]}" if options[:files]}
#{"t.options = #{options[:options]}" if options[:options]}
end
}
end
if task_def
rakefile_content = %Q{
require 'foodcritic'
task :default => [:#{options[:name] ? options[:name] : 'foodcritic'}]
#{task_def}
}
end
write_file "cookbooks/example/Rakefile", rakefile_content
end | ruby | {
"resource": ""
} |
q15564 | FoodCritic.CookbookHelpers.recipe_installs_gem | train | def recipe_installs_gem(type, action = :install)
case type
when :simple
write_recipe %Q{
gem_package "bluepill" do
action :#{action}
end
}.strip
when :compile_time
write_recipe %Q{
r = gem_package "mysql" do
action :nothing
end
r.run_action(:#{action})
Gem.clear_paths
}.strip
when :compile_time_from_array
write_recipe %Q{
['foo', 'bar', 'baz'].each do |pkg|
r = gem_package pkg do
action :nothing
end
r.run_action(:#{action})
end
}.strip
when :compile_time_from_word_list
write_recipe %Q{
%w{foo bar baz}.each do |pkg|
r = gem_package pkg do
action :nothing
end
r.run_action(:#{action})
end
}.strip
else
raise "Unrecognised type: #{type}"
end
end | ruby | {
"resource": ""
} |
q15565 | FoodCritic.CookbookHelpers.recipe_with_dependency | train | def recipe_with_dependency(dep)
dep = { :is_scoped => true, :is_declared => true,
:parentheses => false }.merge!(dep)
recipe = "foo#{dep[:is_scoped] ? '::default' : ''}"
write_recipe(if dep[:parentheses]
"include_recipe('#{recipe}')"
else
"include_recipe '#{recipe}'"
end)
write_metadata %Q{
version "1.9.0"
depends "#{dep[:is_declared] ? 'foo' : 'dogs'}"
}
end | ruby | {
"resource": ""
} |
q15566 | FoodCritic.CookbookHelpers.recipe_with_ruby_block | train | def recipe_with_ruby_block(length)
recipe = ""
if length == :short || length == :both
recipe << %q{
ruby_block "subexpressions" do
block do
rc = Chef::Util::FileEdit.new("/foo/bar.conf")
rc.search_file_replace_line(/^search/, "search #{node["foo"]["bar"]} compute-1.internal")
rc.search_file_replace_line(/^domain/, "domain #{node["foo"]["bar"]}")
rc.write_file
end
action :create
end
}
end
if length == :long || length == :both
recipe << %q{
ruby_block "too_long" do
block do
begin
do_something('with argument')
do_something_else('with another argument')
foo = Foo.new('bar')
foo.activate_turbo_boost
foo.each do |thing|
case thing
when "fee"
puts 'Fee'
when "fi"
puts 'Fi'
when "fo"
puts 'Fo'
else
puts "Fum"
end
end
rescue Some::Exception
Chef::Log.warn "Problem activating the turbo boost"
end
end
action :create
end
}
end
write_recipe(recipe)
end | ruby | {
"resource": ""
} |
q15567 | FoodCritic.CookbookHelpers.role | train | def role(options = {})
options = { :format => :ruby, :dir => "roles" }.merge(options)
content = if options[:format] == :json
%Q{
{
"chef_type": "role",
"json_class": "Chef::Role",
#{Array(options[:role_name]).map { |r| "name: #{r}," }.join("\n")}
"run_list": [
"recipe[apache2]",
]
}
}
else
%Q{
#{Array(options[:role_name]).map { |r| "name #{r}" }.join("\n")}
run_list "recipe[apache2]"
}
end
write_file "#{options[:dir]}/#{options[:file_name]}", content.strip
end | ruby | {
"resource": ""
} |
q15568 | FoodCritic.Review.to_s | train | def to_s
# Sorted by filename and line number.
#
# FC123: My rule name: foo/recipes/default.rb
@warnings.map do |w|
["#{w.rule.code}: #{w.rule.name}: #{w.match[:filename]}",
w.match[:line].to_i]
end.sort do |x, y|
x.first == y.first ? x[1] <=> y[1] : x.first <=> y.first
end.map { |w| "#{w.first}:#{w[1]}" }.uniq.join("\n")
end | ruby | {
"resource": ""
} |
q15569 | JenkinsApi.Client.get_artifact | train | def get_artifact(job_name,filename)
@artifact = job.find_artifact(job_name)
response = make_http_request(Net::HTTP::Get.new(@artifact))
if response.code == "200"
File.write(File.expand_path(filename), response.body)
else
raise "Couldn't get the artifact"
end
end | ruby | {
"resource": ""
} |
q15570 | JenkinsApi.Client.get_artifacts | train | def get_artifacts(job_name, dldir, build_number = nil)
@artifacts = job.find_artifacts(job_name,build_number)
results = []
@artifacts.each do |artifact|
uri = URI.parse(artifact)
http = Net::HTTP.new(uri.host, uri.port)
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
http.use_ssl = @ssl
request = Net::HTTP::Get.new(uri.request_uri)
request.basic_auth(@username, @password)
response = http.request(request)
# we want every thing after the last 'build' in the path to become the filename
if artifact.include?('/build/')
filename = artifact.split("/build/").last.gsub('/','-')
else
filename = File.basename(artifact)
end
filename = File.join(dldir, filename)
results << filename
if response.code == "200"
File.write(File.expand_path(filename), response.body)
else
raise "Couldn't get the artifact #{artifact} for job #{job}"
end
end
results
end | ruby | {
"resource": ""
} |
q15571 | JenkinsApi.Client.make_http_request | train | def make_http_request(request, follow_redirect = @follow_redirects)
request.basic_auth @username, @password if @username
request['Cookie'] = @cookies if @cookies
if @proxy_ip
case @proxy_protocol
when 'http'
http = Net::HTTP::Proxy(@proxy_ip, @proxy_port).new(@server_ip, @server_port)
when 'socks'
http = Net::HTTP::SOCKSProxy(@proxy_ip, @proxy_port).start(@server_ip, @server_port)
else
raise "unknown proxy protocol: '#{@proxy_protocol}'"
end
else
http = Net::HTTP.new(@server_ip, @server_port)
end
if @ssl && @pkcs_file_path
http.use_ssl = true
pkcs12 =OpenSSL::PKCS12.new(File.binread(@pkcs_file_path), @pass_phrase!=nil ? @pass_phrase : "")
http.cert = pkcs12.certificate
http.key = pkcs12.key
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
elsif @ssl
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_PEER
http.ca_file = @ca_file if @ca_file
end
http.open_timeout = @http_open_timeout
http.read_timeout = @http_read_timeout
response = http.request(request)
case response
when Net::HTTPRedirection then
# If we got a redirect request, follow it (if flag set), but don't
# go any deeper (only one redirect supported - don't want to follow
# our tail)
if follow_redirect
redir_uri = URI.parse(response['location'])
response = make_http_request(
Net::HTTP::Get.new(redir_uri.path, false)
)
end
end
# Pick out some useful header info before we return
@jenkins_version = response['X-Jenkins']
@hudson_version = response['X-Hudson']
return response
end | ruby | {
"resource": ""
} |
q15572 | JenkinsApi.Client.api_get_request | train | def api_get_request(url_prefix, tree = nil, url_suffix ="/api/json",
raw_response = false)
url_prefix = "#{@jenkins_path}#{url_prefix}"
to_get = ""
if tree
to_get = "#{url_prefix}#{url_suffix}?#{tree}"
else
to_get = "#{url_prefix}#{url_suffix}"
end
request = Net::HTTP::Get.new(to_get)
@logger.debug "GET #{to_get}"
response = make_http_request(request)
if raw_response
handle_exception(response, "raw")
else
handle_exception(response, "body", url_suffix =~ /json/)
end
end | ruby | {
"resource": ""
} |
q15573 | JenkinsApi.Client.api_post_request | train | def api_post_request(url_prefix, form_data = {}, raw_response = false)
retries = @crumb_max_retries
begin
refresh_crumbs
# Added form_data default {} instead of nil to help with proxies
# that barf with empty post
request = Net::HTTP::Post.new("#{@jenkins_path}#{url_prefix}")
@logger.debug "POST #{url_prefix}"
if @crumbs_enabled
request[@crumb["crumbRequestField"]] = @crumb["crumb"]
end
request.set_form_data(form_data)
response = make_http_request(request)
if raw_response
handle_exception(response, "raw")
else
handle_exception(response)
end
rescue Exceptions::ForbiddenException => e
refresh_crumbs(true)
if @crumbs_enabled
@logger.info "Retrying: #{@crumb_max_retries - retries + 1} out of" +
" #{@crumb_max_retries} times..."
retries -= 1
if retries > 0
retry
else
raise Exceptions::ForbiddenWithCrumb.new(@logger, e.message)
end
else
raise
end
end
end | ruby | {
"resource": ""
} |
q15574 | JenkinsApi.Client.get_config | train | def get_config(url_prefix)
request = Net::HTTP::Get.new("#{@jenkins_path}#{url_prefix}/config.xml")
@logger.debug "GET #{url_prefix}/config.xml"
response = make_http_request(request)
handle_exception(response, "body")
end | ruby | {
"resource": ""
} |
q15575 | JenkinsApi.Client.exec_cli | train | def exec_cli(command, args = [])
base_dir = File.dirname(__FILE__)
server_url = "http://#{@server_ip}:#{@server_port}/#{@jenkins_path}"
cmd = "java -jar #{base_dir}/../../java_deps/jenkins-cli.jar -s #{server_url}"
cmd << " -i #{@identity_file}" if @identity_file && !@identity_file.empty?
cmd << " #{command}"
cmd << " --username #{@username} --password #{@password}" if @identity_file.nil? || @identity_file.empty?
cmd << ' '
cmd << args.join(' ')
java_cmd = Mixlib::ShellOut.new(cmd)
# Run the command
java_cmd.run_command
if java_cmd.stderr.empty?
java_cmd.stdout.chomp
else
# The stderr has a stack trace of the Java program. We'll already have
# a stack trace for Ruby. So just display a descriptive message for the
# error thrown by the CLI.
raise Exceptions::CLIException.new(
@logger,
java_cmd.stderr.split("\n").first
)
end
end | ruby | {
"resource": ""
} |
q15576 | JenkinsApi.Client.symbolize_keys | train | def symbolize_keys(hash)
hash.inject({}){|result, (key, value)|
new_key = case key
when String then key.to_sym
else key
end
new_value = case value
when Hash then symbolize_keys(value)
else value
end
result[new_key] = new_value
result
}
end | ruby | {
"resource": ""
} |
q15577 | JenkinsApi.Client.handle_exception | train | def handle_exception(response, to_send = "code", send_json = false)
msg = "HTTP Code: #{response.code}, Response Body: #{response.body}"
@logger.debug msg
case response.code.to_i
# As of Jenkins version 1.519, the job builds return a 201 status code
# with a Location HTTP header with the pointing the URL of the item in
# the queue.
when 200, 201, 302
if to_send == "body" && send_json
return JSON.parse(response.body)
elsif to_send == "body"
return response.body
elsif to_send == "code"
return response.code
elsif to_send == "raw"
return response
end
when 400
matched = response.body.match(/<p>(.*)<\/p>/)
api_message = matched[1] unless matched.nil?
@logger.debug "API message: #{api_message}"
case api_message
when /A job already exists with the name/
raise Exceptions::JobAlreadyExists.new(@logger, api_message)
when /A view already exists with the name/
raise Exceptions::ViewAlreadyExists.new(@logger, api_message)
when /Slave called .* already exists/
raise Exceptions::NodeAlreadyExists.new(@logger, api_message)
when /Nothing is submitted/
raise Exceptions::NothingSubmitted.new(@logger, api_message)
else
raise Exceptions::ApiException.new(@logger, api_message)
end
when 401
raise Exceptions::Unauthorized.new @logger
when 403
raise Exceptions::Forbidden.new @logger
when 404
raise Exceptions::NotFound.new @logger
when 500
matched = response.body.match(/Exception: (.*)<br>/)
api_message = matched[1] unless matched.nil?
@logger.debug "API message: #{api_message}"
raise Exceptions::InternalServerError.new(@logger, api_message)
when 503
raise Exceptions::ServiceUnavailable.new @logger
else
raise Exceptions::ApiException.new(
@logger,
"Error code #{response.code}"
)
end
end | ruby | {
"resource": ""
} |
q15578 | Bugsnag.Report.add_tab | train | def add_tab(name, value)
return if name.nil?
if value.is_a? Hash
meta_data[name] ||= {}
meta_data[name].merge! value
else
meta_data["custom"] = {} unless meta_data["custom"]
meta_data["custom"][name.to_s] = value
end
end | ruby | {
"resource": ""
} |
q15579 | Bugsnag.Report.as_json | train | def as_json
# Build the payload's exception event
payload_event = {
app: {
version: app_version,
releaseStage: release_stage,
type: app_type
},
context: context,
device: {
hostname: hostname
},
exceptions: exceptions,
groupingHash: grouping_hash,
session: session,
severity: severity,
severityReason: severity_reason,
unhandled: @unhandled,
user: user
}
# cleanup character encodings
payload_event = Bugsnag::Cleaner.clean_object_encoding(payload_event)
# filter out sensitive values in (and cleanup encodings) metaData
filter_cleaner = Bugsnag::Cleaner.new(configuration.meta_data_filters)
payload_event[:metaData] = filter_cleaner.clean_object(meta_data)
payload_event[:breadcrumbs] = breadcrumbs.map do |breadcrumb|
breadcrumb_hash = breadcrumb.to_h
breadcrumb_hash[:metaData] = filter_cleaner.clean_object(breadcrumb_hash[:metaData])
breadcrumb_hash
end
payload_event.reject! {|k,v| v.nil? }
# return the payload hash
{
:apiKey => api_key,
:notifier => {
:name => NOTIFIER_NAME,
:version => NOTIFIER_VERSION,
:url => NOTIFIER_URL
},
:events => [payload_event]
}
end | ruby | {
"resource": ""
} |
q15580 | Bugsnag.Report.summary | train | def summary
# Guard against the exceptions array being removed/changed or emptied here
if exceptions.respond_to?(:first) && exceptions.first
{
:error_class => exceptions.first[:errorClass],
:message => exceptions.first[:message],
:severity => severity
}
else
{
:error_class => "Unknown",
:severity => severity
}
end
end | ruby | {
"resource": ""
} |
q15581 | Bugsnag::Breadcrumbs.Validator.valid_meta_data_type? | train | def valid_meta_data_type?(value)
value.nil? || value.is_a?(String) || value.is_a?(Numeric) || value.is_a?(FalseClass) || value.is_a?(TrueClass)
end | ruby | {
"resource": ""
} |
q15582 | Bugsnag.Rack.call | train | def call(env)
# Set the request data for bugsnag middleware to use
Bugsnag.configuration.set_request_data(:rack_env, env)
if Bugsnag.configuration.auto_capture_sessions
Bugsnag.start_session
end
begin
response = @app.call(env)
rescue Exception => raised
# Notify bugsnag of rack exceptions
Bugsnag.notify(raised, true) do |report|
report.severity = "error"
report.severity_reason = {
:type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
:attributes => Bugsnag::Rack::FRAMEWORK_ATTRIBUTES
}
end
# Re-raise the exception
raise
end
# Notify bugsnag of rack exceptions
if env["rack.exception"]
Bugsnag.notify(env["rack.exception"], true) do |report|
report.severity = "error"
report.severity_reason = {
:type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
:attributes => FRAMEWORK_ATTRIBUTES
}
end
end
response
ensure
# Clear per-request data after processing the each request
Bugsnag.configuration.clear_request_data
end | ruby | {
"resource": ""
} |
q15583 | Bugsnag.SessionTracker.start_session | train | def start_session
return unless Bugsnag.configuration.enable_sessions
start_delivery_thread
start_time = Time.now().utc().strftime('%Y-%m-%dT%H:%M:00')
new_session = {
:id => SecureRandom.uuid,
:startedAt => start_time,
:events => {
:handled => 0,
:unhandled => 0
}
}
SessionTracker.set_current_session(new_session)
add_session(start_time)
end | ruby | {
"resource": ""
} |
q15584 | Bugsnag.SessionTracker.send_sessions | train | def send_sessions
sessions = []
counts = @session_counts
@session_counts = Concurrent::Hash.new(0)
counts.each do |min, count|
sessions << {
:startedAt => min,
:sessionsStarted => count
}
end
deliver(sessions)
end | ruby | {
"resource": ""
} |
q15585 | Bugsnag.Railtie.event_subscription | train | def event_subscription(event)
ActiveSupport::Notifications.subscribe(event[:id]) do |*, event_id, data|
filtered_data = data.slice(*event[:allowed_data])
filtered_data[:event_name] = event[:id]
filtered_data[:event_id] = event_id
if event[:id] == "sql.active_record"
binds = data[:binds].each_with_object({}) { |bind, output| output[bind.name] = '?' if defined?(bind.name) }
filtered_data[:binds] = JSON.dump(binds) unless binds.empty?
end
Bugsnag.leave_breadcrumb(
event[:message],
filtered_data,
event[:type],
:auto
)
end
end | ruby | {
"resource": ""
} |
q15586 | Bugsnag.Resque.save | train | def save
Bugsnag.notify(exception, true) do |report|
report.severity = "error"
report.severity_reason = {
:type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
:attributes => FRAMEWORK_ATTRIBUTES
}
context = "#{payload['class']}@#{queue}"
report.meta_data.merge!({:context => context, :payload => payload})
report.context = context
end
end | ruby | {
"resource": ""
} |
q15587 | Bugsnag.MiddlewareStack.insert_after | train | def insert_after(after, new_middleware)
@mutex.synchronize do
return if @disabled_middleware.include?(new_middleware)
return if @middlewares.include?(new_middleware)
if after.is_a? Array
index = @middlewares.rindex {|el| after.include?(el)}
else
index = @middlewares.rindex(after)
end
if index.nil?
@middlewares << new_middleware
else
@middlewares.insert index + 1, new_middleware
end
end
end | ruby | {
"resource": ""
} |
q15588 | Bugsnag.MiddlewareStack.insert_before | train | def insert_before(before, new_middleware)
@mutex.synchronize do
return if @disabled_middleware.include?(new_middleware)
return if @middlewares.include?(new_middleware)
if before.is_a? Array
index = @middlewares.index {|el| before.include?(el)}
else
index = @middlewares.index(before)
end
@middlewares.insert index || @middlewares.length, new_middleware
end
end | ruby | {
"resource": ""
} |
q15589 | Bugsnag.MiddlewareStack.run | train | def run(report)
# The final lambda is the termination of the middleware stack. It calls deliver on the notification
lambda_has_run = false
notify_lambda = lambda do |notif|
lambda_has_run = true
yield if block_given?
end
begin
# We reverse them, so we can call "call" on the first middleware
middleware_procs.reverse.inject(notify_lambda) { |n,e| e.call(n) }.call(report)
rescue StandardError => e
# KLUDGE: Since we don't re-raise middleware exceptions, this breaks rspec
raise if e.class.to_s == "RSpec::Expectations::ExpectationNotMetError"
# We dont notify, as we dont want to loop forever in the case of really broken middleware, we will
# still send this notify
Bugsnag.configuration.warn "Bugsnag middleware error: #{e}"
Bugsnag.configuration.warn "Middleware error stacktrace: #{e.backtrace.inspect}"
end
# Ensure that the deliver has been performed, and no middleware has botched it
notify_lambda.call(report) unless lambda_has_run
end | ruby | {
"resource": ""
} |
q15590 | Bugsnag.MongoBreadcrumbSubscriber.leave_mongo_breadcrumb | train | def leave_mongo_breadcrumb(event_name, event)
message = MONGO_MESSAGE_PREFIX + event_name
meta_data = {
:event_name => MONGO_EVENT_PREFIX + event_name,
:command_name => event.command_name,
:database_name => event.database_name,
:operation_id => event.operation_id,
:request_id => event.request_id,
:duration => event.duration
}
if (command = pop_command(event.request_id))
collection_key = event.command_name == "getMore" ? "collection" : event.command_name
meta_data[:collection] = command[collection_key]
unless command["filter"].nil?
filter = sanitize_filter_hash(command["filter"])
meta_data[:filter] = JSON.dump(filter)
end
end
meta_data[:message] = event.message if defined?(event.message)
Bugsnag.leave_breadcrumb(message, meta_data, Bugsnag::Breadcrumbs::PROCESS_BREADCRUMB_TYPE, :auto)
end | ruby | {
"resource": ""
} |
q15591 | Bugsnag.MongoBreadcrumbSubscriber.sanitize_filter_hash | train | def sanitize_filter_hash(filter_hash, depth = 0)
filter_hash.each_with_object({}) do |(key, value), output|
output[key] = sanitize_filter_value(value, depth)
end
end | ruby | {
"resource": ""
} |
q15592 | Bugsnag.MongoBreadcrumbSubscriber.sanitize_filter_value | train | def sanitize_filter_value(value, depth)
depth += 1
if depth >= MAX_FILTER_DEPTH
'[MAX_FILTER_DEPTH_REACHED]'
elsif value.is_a?(Array)
value.map { |array_value| sanitize_filter_value(array_value, depth) }
elsif value.is_a?(Hash)
sanitize_filter_hash(value, depth)
else
'?'
end
end | ruby | {
"resource": ""
} |
q15593 | Bugsnag.Configuration.parse_proxy | train | def parse_proxy(uri)
proxy = URI.parse(uri)
self.proxy_host = proxy.host
self.proxy_port = proxy.port
self.proxy_user = proxy.user
self.proxy_password = proxy.password
end | ruby | {
"resource": ""
} |
q15594 | Bugsnag.Mailman.call | train | def call(mail)
begin
Bugsnag.configuration.set_request_data :mailman_msg, mail.to_s
yield
rescue Exception => ex
Bugsnag.notify(ex, true) do |report|
report.severity = "error"
report.severity_reason = {
:type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
:attributes => FRAMEWORK_ATTRIBUTES
}
end
raise
ensure
Bugsnag.configuration.clear_request_data
end
end | ruby | {
"resource": ""
} |
q15595 | SimpleNavigation.Helpers.render_navigation | train | def render_navigation(options = {}, &block)
container = active_navigation_item_container(options, &block)
container && container.render(options)
end | ruby | {
"resource": ""
} |
q15596 | SimpleNavigation.Helpers.active_navigation_item | train | def active_navigation_item(options = {}, value_for_nil = nil)
if options[:level].nil? || options[:level] == :all
options[:level] = :leaves
end
container = active_navigation_item_container(options)
if container && (item = container.selected_item)
block_given? ? yield(item) : item
else
value_for_nil
end
end | ruby | {
"resource": ""
} |
q15597 | SimpleNavigation.Helpers.active_navigation_item_container | train | def active_navigation_item_container(options = {}, &block)
options = SimpleNavigation::Helpers.apply_defaults(options)
SimpleNavigation::Helpers.load_config(options, self, &block)
SimpleNavigation.active_item_container_for(options[:level])
end | ruby | {
"resource": ""
} |
q15598 | SimpleNavigation.Item.html_options | train | def html_options
html_opts = options.fetch(:html) { Hash.new }
html_opts[:id] ||= autogenerated_item_id
classes = [html_opts[:class], selected_class, active_leaf_class]
classes = classes.flatten.compact.join(' ')
html_opts[:class] = classes if classes && !classes.empty?
html_opts
end | ruby | {
"resource": ""
} |
q15599 | SimpleNavigation.ItemContainer.item | train | def item(key, name, url = nil, options = {}, &block)
return unless should_add_item?(options)
item = Item.new(self, key, name, url, options, &block)
add_item item, options
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.