File vm_common.rb
has 1172 lines of code (exceeds 400 allowed). Consider refactoring. Open
module VmCommon
extend ActiveSupport::Concern
include ActionView::Helpers::JavaScriptHelper
include Mixins::ChargebackPreviewMixin
include ProvisionCustomizeHelper
- Create a ticketCreate a ticket
Method replace_right_cell
has a Cognitive Complexity of 91 (exceeds 5 allowed). Consider refactoring. Open
def replace_right_cell(options = {})
if params[:action] == 'x_history'
# Making selected checkboxes array empty when compare cancel is clicked
params[:miq_grid_checks] = []
end
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method show
has a Cognitive Complexity of 59 (exceeds 5 allowed). Consider refactoring. Open
def show(id = nil)
@flash_array = [] if params[:display] && params[:display] != "snapshot_info"
@sb[:action] = params[:display]
return if perfmenu_click?
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Cyclomatic complexity for replace_right_cell is too high. [60/11] Open
def replace_right_cell(options = {})
if params[:action] == 'x_history'
# Making selected checkboxes array empty when compare cancel is clicked
params[:miq_grid_checks] = []
end
- Read upRead up
- Create a ticketCreate a ticket
- Exclude checks
Checks that the cyclomatic complexity of methods is not higher than the configured maximum. The cyclomatic complexity is the number of linearly independent paths through a method. The algorithm counts decision points and adds one.
An if statement (or unless or ?:) increases the complexity by one. An else branch does not, since it doesn't add a decision point. The && operator (or keyword and) can be converted to a nested if statement, and ||/or is shorthand for a sequence of ifs, so they also add one. Loops can be said to have an exit condition, so they add one. Blocks that are calls to builtin iteration methods (e.g. `ary.map{...}) also add one, others are ignored.
def each_child_node(*types) # count begins: 1
unless block_given? # unless: +1
return to_enum(__method__, *types)
children.each do |child| # each{}: +1
next unless child.is_a?(Node) # unless: +1
yield child if types.empty? || # if: +1, ||: +1
types.include?(child.type)
end
self
end # total: 6
Method list_child_vms
has a Cognitive Complexity of 46 (exceeds 5 allowed). Consider refactoring. Open
def list_child_vms(model, node_id, title, show_list)
options = {
:model => model,
:named_scope => scopes_for_role,
}
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method set_right_cell_vars
has 172 lines of code (exceeds 25 allowed). Consider refactoring. Open
def set_right_cell_vars(options = {})
name = @record.try(:name).to_s
table = request.parameters["controller"]
case @sb[:action]
when "attach"
- Create a ticketCreate a ticket
Method replace_right_cell
has 148 lines of code (exceeds 25 allowed). Consider refactoring. Open
def replace_right_cell(options = {})
if params[:action] == 'x_history'
# Making selected checkboxes array empty when compare cancel is clicked
params[:miq_grid_checks] = []
end
- Create a ticketCreate a ticket
Cyclomatic complexity for show is too high. [43/11] Open
def show(id = nil)
@flash_array = [] if params[:display] && params[:display] != "snapshot_info"
@sb[:action] = params[:display]
return if perfmenu_click?
- Read upRead up
- Create a ticketCreate a ticket
- Exclude checks
Checks that the cyclomatic complexity of methods is not higher than the configured maximum. The cyclomatic complexity is the number of linearly independent paths through a method. The algorithm counts decision points and adds one.
An if statement (or unless or ?:) increases the complexity by one. An else branch does not, since it doesn't add a decision point. The && operator (or keyword and) can be converted to a nested if statement, and ||/or is shorthand for a sequence of ifs, so they also add one. Loops can be said to have an exit condition, so they add one. Blocks that are calls to builtin iteration methods (e.g. `ary.map{...}) also add one, others are ignored.
def each_child_node(*types) # count begins: 1
unless block_given? # unless: +1
return to_enum(__method__, *types)
children.each do |child| # each{}: +1
next unless child.is_a?(Node) # unless: +1
yield child if types.empty? || # if: +1, ||: +1
types.include?(child.type)
end
self
end # total: 6
Cyclomatic complexity for set_right_cell_vars is too high. [40/11] Open
def set_right_cell_vars(options = {})
name = @record.try(:name).to_s
table = request.parameters["controller"]
case @sb[:action]
when "attach"
- Read upRead up
- Create a ticketCreate a ticket
- Exclude checks
Checks that the cyclomatic complexity of methods is not higher than the configured maximum. The cyclomatic complexity is the number of linearly independent paths through a method. The algorithm counts decision points and adds one.
An if statement (or unless or ?:) increases the complexity by one. An else branch does not, since it doesn't add a decision point. The && operator (or keyword and) can be converted to a nested if statement, and ||/or is shorthand for a sequence of ifs, so they also add one. Loops can be said to have an exit condition, so they add one. Blocks that are calls to builtin iteration methods (e.g. `ary.map{...}) also add one, others are ignored.
def each_child_node(*types) # count begins: 1
unless block_given? # unless: +1
return to_enum(__method__, *types)
children.each do |child| # each{}: +1
next unless child.is_a?(Node) # unless: +1
yield child if types.empty? || # if: +1, ||: +1
types.include?(child.type)
end
self
end # total: 6
Method show
has 122 lines of code (exceeds 25 allowed). Consider refactoring. Open
def show(id = nil)
@flash_array = [] if params[:display] && params[:display] != "snapshot_info"
@sb[:action] = params[:display]
return if perfmenu_click?
- Create a ticketCreate a ticket
Method set_right_cell_vars
has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring. Open
def set_right_cell_vars(options = {})
name = @record.try(:name).to_s
table = request.parameters["controller"]
case @sb[:action]
when "attach"
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Cyclomatic complexity for list_child_vms is too high. [25/11] Open
def list_child_vms(model, node_id, title, show_list)
options = {
:model => model,
:named_scope => scopes_for_role,
}
- Read upRead up
- Create a ticketCreate a ticket
- Exclude checks
Checks that the cyclomatic complexity of methods is not higher than the configured maximum. The cyclomatic complexity is the number of linearly independent paths through a method. The algorithm counts decision points and adds one.
An if statement (or unless or ?:) increases the complexity by one. An else branch does not, since it doesn't add a decision point. The && operator (or keyword and) can be converted to a nested if statement, and ||/or is shorthand for a sequence of ifs, so they also add one. Loops can be said to have an exit condition, so they add one. Blocks that are calls to builtin iteration methods (e.g. `ary.map{...}) also add one, others are ignored.
def each_child_node(*types) # count begins: 1
unless block_given? # unless: +1
return to_enum(__method__, *types)
children.each do |child| # each{}: +1
next unless child.is_a?(Node) # unless: +1
yield child if types.empty? || # if: +1, ||: +1
types.include?(child.type)
end
self
end # total: 6
Cyclomatic complexity for action_type is too high. [24/11] Open
def action_type(type, amount)
case type
when "advanced_settings"
n_("Advanced Setting", "Advanced Settings", amount)
when "disks"
- Read upRead up
- Create a ticketCreate a ticket
- Exclude checks
Checks that the cyclomatic complexity of methods is not higher than the configured maximum. The cyclomatic complexity is the number of linearly independent paths through a method. The algorithm counts decision points and adds one.
An if statement (or unless or ?:) increases the complexity by one. An else branch does not, since it doesn't add a decision point. The && operator (or keyword and) can be converted to a nested if statement, and ||/or is shorthand for a sequence of ifs, so they also add one. Loops can be said to have an exit condition, so they add one. Blocks that are calls to builtin iteration methods (e.g. `ary.map{...}) also add one, others are ignored.
def each_child_node(*types) # count begins: 1
unless block_given? # unless: +1
return to_enum(__method__, *types)
children.each do |child| # each{}: +1
next unless child.is_a?(Node) # unless: +1
yield child if types.empty? || # if: +1, ||: +1
types.include?(child.type)
end
self
end # total: 6
Method button
has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring. Open
def button
@edit = session[:edit] # Restore @edit for adv search box
params[:page] = @current_page unless @current_page.nil? # Save current page for list refresh
@refresh_div = "main_div" # Default div for button.rjs to refresh
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Cyclomatic complexity for button is too high. [20/11] Open
def button
@edit = session[:edit] # Restore @edit for adv search box
params[:page] = @current_page unless @current_page.nil? # Save current page for list refresh
@refresh_div = "main_div" # Default div for button.rjs to refresh
- Read upRead up
- Create a ticketCreate a ticket
- Exclude checks
Checks that the cyclomatic complexity of methods is not higher than the configured maximum. The cyclomatic complexity is the number of linearly independent paths through a method. The algorithm counts decision points and adds one.
An if statement (or unless or ?:) increases the complexity by one. An else branch does not, since it doesn't add a decision point. The && operator (or keyword and) can be converted to a nested if statement, and ||/or is shorthand for a sequence of ifs, so they also add one. Loops can be said to have an exit condition, so they add one. Blocks that are calls to builtin iteration methods (e.g. `ary.map{...}) also add one, others are ignored.
def each_child_node(*types) # count begins: 1
unless block_given? # unless: +1
return to_enum(__method__, *types)
children.each do |child| # each{}: +1
next unless child.is_a?(Node) # unless: +1
yield child if types.empty? || # if: +1, ||: +1
types.include?(child.type)
end
self
end # total: 6
Method get_node_info
has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring. Open
def get_node_info(treenodeid, show_list = true)
# resetting action that was stored during edit to determine what is being edited
@sb[:action] = nil
@nodetype, node_id =
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method list_child_vms
has 57 lines of code (exceeds 25 allowed). Consider refactoring. Open
def list_child_vms(model, node_id, title, show_list)
options = {
:model => model,
:named_scope => scopes_for_role,
}
- Create a ticketCreate a ticket
Method tree_select
has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring. Open
def tree_select
assert_accordion_and_tree_privileges(x_active_tree)
params[:miq_grid_checks] = []
@explorer = true
@lastaction = "explorer"
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Cyclomatic complexity for tree_select is too high. [14/11] Open
def tree_select
assert_accordion_and_tree_privileges(x_active_tree)
params[:miq_grid_checks] = []
@explorer = true
@lastaction = "explorer"
- Read upRead up
- Create a ticketCreate a ticket
- Exclude checks
Checks that the cyclomatic complexity of methods is not higher than the configured maximum. The cyclomatic complexity is the number of linearly independent paths through a method. The algorithm counts decision points and adds one.
An if statement (or unless or ?:) increases the complexity by one. An else branch does not, since it doesn't add a decision point. The && operator (or keyword and) can be converted to a nested if statement, and ||/or is shorthand for a sequence of ifs, so they also add one. Loops can be said to have an exit condition, so they add one. Blocks that are calls to builtin iteration methods (e.g. `ary.map{...}) also add one, others are ignored.
def each_child_node(*types) # count begins: 1
unless block_given? # unless: +1
return to_enum(__method__, *types)
children.each do |child| # each{}: +1
next unless child.is_a?(Node) # unless: +1
yield child if types.empty? || # if: +1, ||: +1
types.include?(child.type)
end
self
end # total: 6
Method action_type
has 48 lines of code (exceeds 25 allowed). Consider refactoring. Open
def action_type(type, amount)
case type
when "advanced_settings"
n_("Advanced Setting", "Advanced Settings", amount)
when "disks"
- Create a ticketCreate a ticket
Method button
has 46 lines of code (exceeds 25 allowed). Consider refactoring. Open
def button
@edit = session[:edit] # Restore @edit for adv search box
params[:page] = @current_page unless @current_page.nil? # Save current page for list refresh
@refresh_div = "main_div" # Default div for button.rjs to refresh
- Create a ticketCreate a ticket
Cyclomatic complexity for parent_folder_id is too high. [12/11] Open
def parent_folder_id(vm)
if vm.orphaned
"xx-orph"
elsif vm.archived
"xx-arch"
- Read upRead up
- Create a ticketCreate a ticket
- Exclude checks
Checks that the cyclomatic complexity of methods is not higher than the configured maximum. The cyclomatic complexity is the number of linearly independent paths through a method. The algorithm counts decision points and adds one.
An if statement (or unless or ?:) increases the complexity by one. An else branch does not, since it doesn't add a decision point. The && operator (or keyword and) can be converted to a nested if statement, and ||/or is shorthand for a sequence of ifs, so they also add one. Loops can be said to have an exit condition, so they add one. Blocks that are calls to builtin iteration methods (e.g. `ary.map{...}) also add one, others are ignored.
def each_child_node(*types) # count begins: 1
unless block_given? # unless: +1
return to_enum(__method__, *types)
children.each do |child| # each{}: +1
next unless child.is_a?(Node) # unless: +1
yield child if types.empty? || # if: +1, ||: +1
types.include?(child.type)
end
self
end # total: 6
Method parent_folder_id
has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring. Open
def parent_folder_id(vm)
if vm.orphaned
"xx-orph"
elsif vm.archived
"xx-arch"
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method tree_select
has 31 lines of code (exceeds 25 allowed). Consider refactoring. Open
def tree_select
assert_accordion_and_tree_privileges(x_active_tree)
params[:miq_grid_checks] = []
@explorer = true
@lastaction = "explorer"
- Create a ticketCreate a ticket
Method get_node_info
has 30 lines of code (exceeds 25 allowed). Consider refactoring. Open
def get_node_info(treenodeid, show_list = true)
# resetting action that was stored during edit to determine what is being edited
@sb[:action] = nil
@nodetype, node_id =
- Create a ticketCreate a ticket
Method policies
has 30 lines of code (exceeds 25 allowed). Consider refactoring. Open
def policies
@vm = @record = identify_record(params[:id], VmOrTemplate)
@lastaction = "rsop"
@showtype = "policies"
drop_breadcrumb(:name => _("Policy Simulation Details for %{name}") % {:name => @record.name},
- Create a ticketCreate a ticket
Method scan_histories
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
def scan_histories
@vm = @record = identify_record(params[:id], VmOrTemplate)
@explorer = true if request.xml_http_request? # Ajax request means in explorer
@scan_history = ScanHistory.find_by(:vm_or_template_id => @record.id)
if @scan_history.nil?
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Avoid deeply nested control flow statements. Open
process_show_list(options) if show_list
- Create a ticketCreate a ticket
Avoid deeply nested control flow statements. Open
@right_cell_text = if model
_("Archived %{models}") % {:models => ui_lookup(:models => model)}
else
_("Archived VMs & Templates")
end
- Create a ticketCreate a ticket
Method scan_history
has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring. Open
def scan_history
@vm = @record = identify_record(params[:id], VmOrTemplate)
@scan_history = ScanHistory.find_by(:vm_or_template_id => @record.id)
@showtype = "scan_history"
@lastaction = "scan_history"
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method policies
has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open
def policies
@vm = @record = identify_record(params[:id], VmOrTemplate)
@lastaction = "rsop"
@showtype = "policies"
drop_breadcrumb(:name => _("Policy Simulation Details for %{name}") % {:name => @record.name},
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method scopes_for_role
has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open
def scopes_for_role
named_scope = []
named_scope << :not_orphaned unless role_allows?(:feature => 'vm_show_list_orphaned')
named_scope << :not_archived unless role_allows?(:feature => 'vm_show_list_archived')
named_scope << :not_retired unless role_allows?(:feature => 'vm_show_list_retired')
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method edit
has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open
def edit
@record = find_record_with_rbac(VmOrTemplate, params[:id]) # Set the VM object
# reset @explorer if coming from explorer views
@edit ||= {}
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method vm_rename
has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open
def vm_rename
@record = find_record_with_rbac(VmOrTemplate, params[:miq_grid_checks] || params[:id])
unless @record.supports?(:rename)
add_flash(_("Renaming selected VM \"%{name}\" is not supported") % {:name => @record.name}, :error)
if @explorer
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Avoid elsif
branches without a body. Open
elsif @lastaction == "show_list"
else
@refresh_partial = "layouts/flash_msg"
@refresh_div = "flash_msg_div"
- Read upRead up
- Create a ticketCreate a ticket
- Exclude checks
Checks for the presence of if
, elsif
and unless
branches without a body.
NOTE: empty else
branches are handled by Style/EmptyElse
.
Safety:
Autocorrection for this cop is not safe. The conditions for empty branches that the autocorrection removes may have side effects, or the logic in subsequent branches may change due to the removal of a previous condition.
Example:
# bad
if condition
end
# bad
unless condition
end
# bad
if condition
do_something
elsif other_condition
end
# good
if condition
do_something
end
# good
unless condition
do_something
end
# good
if condition
do_something
elsif other_condition
do_something_else
end
Example: AllowComments: true (default)
# good
if condition
do_something
elsif other_condition
# noop
end
Example: AllowComments: false
# bad
if condition
do_something
elsif other_condition
# noop
end
Duplicate branch body detected. Open
elsif @lastaction == "show" && ["config"].include?(@showtype)
@refresh_partial = @showtype
elsif @lastaction == "show_list"
else
@refresh_partial = "layouts/flash_msg"
- Read upRead up
- Create a ticketCreate a ticket
- Exclude checks
Checks that there are no repeated bodies
within if/unless
, case-when
, case-in
and rescue
constructs.
With IgnoreLiteralBranches: true
, branches are not registered
as offenses if they return a basic literal value (string, symbol,
integer, float, rational, complex, true
, false
, or nil
), or
return an array, hash, regexp or range that only contains one of
the above basic literal values.
With IgnoreConstantBranches: true
, branches are not registered
as offenses if they return a constant value.
Example:
# bad
if foo
do_foo
do_something_else
elsif bar
do_foo
do_something_else
end
# good
if foo || bar
do_foo
do_something_else
end
# bad
case x
when foo
do_foo
when bar
do_foo
else
do_something_else
end
# good
case x
when foo, bar
do_foo
else
do_something_else
end
# bad
begin
do_something
rescue FooError
handle_error
rescue BarError
handle_error
end
# good
begin
do_something
rescue FooError, BarError
handle_error
end
Example: IgnoreLiteralBranches: true
# good
case size
when "small" then 100
when "medium" then 250
when "large" then 1000
else 250
end
Example: IgnoreConstantBranches: true
# good
case size
when "small" then SMALL_SIZE
when "medium" then MEDIUM_SIZE
when "large" then LARGE_SIZE
else MEDIUM_SIZE
end
Duplicate branch body detected. Open
elsif vm.cloud && vm.availability_zone_id.nil?
TreeBuilder.build_node_id(vm.ext_management_system)
elsif vm.cloud
TreeBuilder.build_node_id(vm.availability_zone)
elsif (blue_folder = vm.parent_blue_folder) && !blue_folder.hidden
- Read upRead up
- Create a ticketCreate a ticket
- Exclude checks
Checks that there are no repeated bodies
within if/unless
, case-when
, case-in
and rescue
constructs.
With IgnoreLiteralBranches: true
, branches are not registered
as offenses if they return a basic literal value (string, symbol,
integer, float, rational, complex, true
, false
, or nil
), or
return an array, hash, regexp or range that only contains one of
the above basic literal values.
With IgnoreConstantBranches: true
, branches are not registered
as offenses if they return a constant value.
Example:
# bad
if foo
do_foo
do_something_else
elsif bar
do_foo
do_something_else
end
# good
if foo || bar
do_foo
do_something_else
end
# bad
case x
when foo
do_foo
when bar
do_foo
else
do_something_else
end
# good
case x
when foo, bar
do_foo
else
do_something_else
end
# bad
begin
do_something
rescue FooError
handle_error
rescue BarError
handle_error
end
# good
begin
do_something
rescue FooError, BarError
handle_error
end
Example: IgnoreLiteralBranches: true
# good
case size
when "small" then 100
when "medium" then 250
when "large" then 1000
else 250
end
Example: IgnoreConstantBranches: true
# good
case size
when "small" then SMALL_SIZE
when "medium" then MEDIUM_SIZE
when "large" then LARGE_SIZE
else MEDIUM_SIZE
end
Wrap expressions with varying precedence with parentheses to avoid ambiguity. Open
drop_breadcrumb(:name => @record.name + _(" (Compliance History - Last %{number} Checks)") % {:number => count},
- Read upRead up
- Create a ticketCreate a ticket
- Exclude checks
Looks for expressions containing multiple binary operators
where precedence is ambiguous due to lack of parentheses. For example,
in 1 + 2 * 3
, the multiplication will happen before the addition, but
lexically it appears that the addition will happen first.
The cop does not consider unary operators (ie. !a
or -b
) or comparison
operators (ie. a =~ b
) because those are not ambiguous.
NOTE: Ranges are handled by Lint/AmbiguousRange
.
Example:
# bad
a + b * c
a || b && c
a ** b + c
# good (different precedence)
a + (b * c)
a || (b && c)
(a ** b) + c
# good (same precedence)
a + b + c
a * b / c % d