Showing 48 of 48 total issues
Cyclomatic complexity for execute is too high. [7/6] Open
def execute
raise ArgumentError.new('Response is already defined, create another Request object.') if self.response
validate!
begin
self.response = shippo_phone_home
- Read upRead up
- Exclude checks
This cop 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.
Method inherited
has 28 lines of code (exceeds 25 allowed). Consider refactoring. Open
def self.inherited(klazz)
klazz.instance_eval do
@allowed_values = Set.new
class << self
def categories
Method execute
has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring. Open
def execute
raise ArgumentError.new('Response is already defined, create another Request object.') if self.response
validate!
begin
self.response = shippo_phone_home
- Read upRead up
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 execute
has 27 lines of code (exceeds 25 allowed). Consider refactoring. Open
def execute
raise ArgumentError.new('Response is already defined, create another Request object.') if self.response
validate!
begin
self.response = shippo_phone_home
Method allowed_values
has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring. Open
def allowed_values(*values)
return @allowed_values if values.nil? || values.empty? || !@allowed_values.empty?
@allowed_values = self.value_transformer(values)
@allowed_values.each do |allowed_value|
- Read upRead up
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 url
has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open
def url(value = nil)
return @url if @url
@url ||= value if value
@url ||= class_to_url
end
- Read upRead up
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
Block has too many lines. [26/25] Open
klazz.instance_eval do
@allowed_values = Set.new
class << self
def categories
::Shippo::API::Category::Base.categories
- Read upRead up
- Exclude checks
This cop checks if the length of a block exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable. The cop can be configured to ignore blocks passed to certain methods.
Extra empty line detected before the rescue
. Open
rescue ::RestClient::BadRequest => e
- Read upRead up
- Exclude checks
This cops checks if empty lines exist around the bodies of begin
sections. This cop doesn't check empty lines at begin
body
beginning/end and around method definition body.
Style/EmptyLinesAroundBeginBody
or Style/EmptyLinesAroundMethodBody
can be used for this purpose.
Example:
# good
begin
do_something
rescue
do_something2
else
do_something3
ensure
do_something4
end
# good
def foo
do_something
rescue
do_something2
end
# bad
begin
do_something
rescue
do_something2
else
do_something3
ensure
do_something4
end
# bad
def foo
do_something
rescue
do_something2
end
Extra empty line detected before the rescue
. Open
rescue ::JSON::JSONError, ::JSON::ParserError => e
- Read upRead up
- Exclude checks
This cops checks if empty lines exist around the bodies of begin
sections. This cop doesn't check empty lines at begin
body
beginning/end and around method definition body.
Style/EmptyLinesAroundBeginBody
or Style/EmptyLinesAroundMethodBody
can be used for this purpose.
Example:
# good
begin
do_something
rescue
do_something2
else
do_something3
ensure
do_something4
end
# good
def foo
do_something
rescue
do_something2
end
# bad
begin
do_something
rescue
do_something2
else
do_something3
ensure
do_something4
end
# bad
def foo
do_something
rescue
do_something2
end
Closing method call brace must be on the line after the last argument when opening brace is on a separate line from the first argument. Open
'API credentials seems to be missing, perhaps you forgot to set Shippo::API.token?') \
- Read upRead up
- Exclude checks
This cop checks that the closing brace in a method call is either on the same line as the last method argument, or a new line.
When using the symmetrical
(default) style:
If a method call's opening brace is on the same line as the first argument of the call, then the closing brace should be on the same line as the last argument of the call.
If an method call's opening brace is on the line above the first argument of the call, then the closing brace should be on the line below the last argument of the call.
When using the new_line
style:
The closing brace of a multi-line method call must be on the line after the last argument of the call.
When using the same_line
style:
The closing brace of a multi-line method call must be on the same line as the last argument of the call.
Example:
# symmetrical: bad
# new_line: good
# same_line: bad
foo(a,
b
)
# symmetrical: bad
# new_line: bad
# same_line: good
foo(
a,
b)
# symmetrical: good
# new_line: bad
# same_line: good
foo(a,
b)
# symmetrical: good
# new_line: good
# same_line: bad
foo(
a,
b
)
Omit parentheses for ternary conditions. Open
(method == :get) ? request_url = params_to_url(params, url) : payload = params.to_json
- Read upRead up
- Exclude checks
This cop checks for the presence of parentheses around ternary
conditions. It is configurable to enforce inclusion or omission of
parentheses using EnforcedStyle
. Omission is only enforced when
removing the parentheses won't cause a different behavior.
Example: EnforcedStyle: requirenoparentheses (default)
# bad
foo = (bar?) ? a : b
foo = (bar.baz?) ? a : b
foo = (bar && baz) ? a : b
# good
foo = bar? ? a : b
foo = bar.baz? ? a : b
foo = bar && baz ? a : b
Example: EnforcedStyle: require_parentheses
# bad
foo = bar? ? a : b
foo = bar.baz? ? a : b
foo = bar && baz ? a : b
# good
foo = (bar?) ? a : b
foo = (bar.baz?) ? a : b
foo = (bar && baz) ? a : b
Example: EnforcedStyle: requireparentheseswhen_complex
# bad
foo = (bar?) ? a : b
foo = (bar.baz?) ? a : b
foo = bar && baz ? a : b
# good
foo = bar? ? a : b
foo = bar.baz? ? a : b
foo = (bar && baz) ? a : b
Favor a normal unless-statement over a modifier clause in a multiline statement. Open
raise Shippo::Exceptions::AuthenticationError.new(
'API credentials seems to be missing, perhaps you forgot to set Shippo::API.token?') \
unless token
- Read upRead up
- Exclude checks
Checks for uses of if/unless modifiers with multiple-lines bodies.
Example:
# bad
{
result: 'this should not happen'
} unless cond
# good
{ result: 'ok' } if cond
Do not use space inside array brackets. Open
@transformers ||= [ Shippo::API::Transformers::List ].freeze
- Read upRead up
- Exclude checks
Checks that brackets used for array literals have or don't have surrounding space depending on configuration.
Example: EnforcedStyle: space
# The `space` style enforces that array literals have
# surrounding space.
# bad
array = [a, b, c, d]
# good
array = [ a, b, c, d ]
Example: EnforcedStyle: no_space
# The `no_space` style enforces that array literals have
# no surrounding space.
# bad
array = [ a, b, c, d ]
# good
array = [a, b, c, d]
Example: EnforcedStyle: compact
# The `compact` style normally requires a space inside
# array brackets, with the exception that successive left
# or right brackets are collapsed together in nested arrays.
# bad
array = [ a, [ b, c ] ]
# good
array = [ a, [ b, c ]]
Extra empty line detected before the rescue
. Open
rescue ::RestClient::Unauthorized => e
- Read upRead up
- Exclude checks
This cops checks if empty lines exist around the bodies of begin
sections. This cop doesn't check empty lines at begin
body
beginning/end and around method definition body.
Style/EmptyLinesAroundBeginBody
or Style/EmptyLinesAroundMethodBody
can be used for this purpose.
Example:
# good
begin
do_something
rescue
do_something2
else
do_something3
ensure
do_something4
end
# good
def foo
do_something
rescue
do_something2
end
# bad
begin
do_something
rescue
do_something2
else
do_something3
ensure
do_something4
end
# bad
def foo
do_something
rescue
do_something2
end
Use each_key
instead of keys.each
. Open
h.keys.each { |k| h[k].is_a?(Array) && !h[k].empty? }.each do |list_key|
- Read upRead up
- Exclude checks
This cop checks for uses of each_key
and each_value
Hash methods.
Note: If you have an array of two-element arrays, you can put parentheses around the block arguments to indicate that you're not working with a hash, and suppress RuboCop offenses.
Example:
# bad
hash.keys.each { |k| p k }
hash.values.each { |v| p v }
hash.each { |k, _v| p k }
hash.each { |_k, v| p v }
# good
hash.each_key { |k| p k }
hash.each_value { |v| p v }
Use the return of the conditional for variable assignment and comparison. Open
if !currency.nil?
response = Shippo::API.get("#{url}/#{shipment_object_id}/rates/#{currency}/", params)
else
response = Shippo::API.get("#{url}/#{shipment_object_id}/rates/", params)
end
- Exclude checks
Unnecessary utf-8 encoding comment. Open
# encoding: utf-8
- Exclude checks
Freeze mutable objects assigned to constants. Open
DOC_FOLDER = 'doc'
- Read upRead up
- Exclude checks
This cop checks whether some constant value isn't a mutable literal (e.g. array or hash).
Example:
# bad
CONST = [1, 2, 3]
# good
CONST = [1, 2, 3].freeze
Do not suppress exceptions. Open
rescue nil
- Read upRead up
- Exclude checks
This cop checks for rescue blocks with no body.
Example:
# bad
def some_method
do_something
rescue
# do nothing
end
Example:
# bad
begin
do_something
rescue
# do nothing
end
Example:
# good
def some_method
do_something
rescue
handle_exception
end
Example:
# good
begin
do_something
rescue
handle_exception
end
Freeze mutable objects assigned to constants. Open
VERSION = '4.1.0'
- Read upRead up
- Exclude checks
This cop checks whether some constant value isn't a mutable literal (e.g. array or hash).
Example:
# bad
CONST = [1, 2, 3]
# good
CONST = [1, 2, 3].freeze