/
cyclomatic_complexity.rb
64 lines (57 loc) · 2.2 KB
/
cyclomatic_complexity.rb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
# frozen_string_literal: true
module RuboCop
module Cop
module Metrics
# 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.
# Blocks that are calls to builtin iteration methods
# (e.g. `ary.map{...}) also add one, otherse 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
class CyclomaticComplexity < Cop
include MethodComplexity
include Utils::IteratingBlock
MSG = 'Cyclomatic complexity for %<method>s is too high. ' \
'[%<complexity>d/%<max>d]'
COUNTED_NODES = %i[if while until for csend block block_pass
rescue when and or or_asgn and_asgn].freeze
private
def complexity_score_for(node)
return 0 if iterating_block?(node) == false
1
end
def block_method(node)
case node.type
when :block
node.method_name
when :block_pass
node.parent.method_name
end
end
def count_block?(block)
KNOWN_ITERATING_METHODS.include? block.method_name
end
end
end
end
end