rubocop 0.78.0

data/lib/rubocop/cop/metrics/perceived_complexity.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop tries to produce a complexity score that's a measure of the
+      # complexity the reader experiences when looking at a method. For that
+      # reason it considers `when` nodes as something that doesn't add as much
+      # complexity as an `if` or a `&&`. Except if it's one of those special
+      # `case`/`when` constructs where there's no expression after `case`. Then
+      # the cop treats it as an `if`/`elsif`/`elsif`... and lets all the `when`
+      # nodes count. In contrast to the CyclomaticComplexity cop, this cop
+      # considers `else` nodes as adding complexity.
+      #
+      # @example
+      #
+      #   def my_method                   # 1
+      #     if cond                       # 1
+      #       case var                    # 2 (0.8 + 4 * 0.2, rounded)
+      #       when 1 then func_one
+      #       when 2 then func_two
+      #       when 3 then func_three
+      #       when 4..10 then func_other
+      #       end
+      #     else                          # 1
+      #       do_something until a && b   # 2
+      #     end                           # ===
+      #   end                             # 7 complexity points
+      class PerceivedComplexity < Cop
+        include MethodComplexity
+
+        MSG = 'Perceived complexity for %<method>s is too high. ' \
+              '[%<complexity>d/%<max>d]'
+        COUNTED_NODES = %i[if case while until
+                           for rescue and or].freeze
+
+        private
+
+        def complexity_score_for(node)
+          case node.type
+          when :case
+            # If cond is nil, that means each when has an expression that
+            # evaluates to true or false. It's just an alternative to
+            # if/elsif/elsif... so the when nodes count.
+            if node.condition.nil?
+              node.when_branches.length
+            else
+              # Otherwise, the case node gets 0.8 complexity points and each
+              # when gets 0.2.
+              (0.8 + 0.2 * node.when_branches.length).round
+            end
+          when :if
+            node.else? && !node.elsif? ? 2 : 1
+          else
+            1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # > ABC is .. a software size metric .. computed by counting the number
+        # > of assignments, branches and conditions for a section of code.
+        # > http://c2.com/cgi/wiki?AbcMetric
+        #
+        # We separate the *calculator* from the *cop* so that the calculation,
+        # the formula itself, is easier to test.
+        class AbcSizeCalculator
+          # > Branch -- an explicit forward program branch out of scope -- a
+          # > function call, class method call ..
+          # > http://c2.com/cgi/wiki?AbcMetric
+          BRANCH_NODES = %i[send csend].freeze
+
+          # > Condition -- a logical/Boolean test, == != <= >= < > else case
+          # > default try catch ? and unary conditionals.
+          # > http://c2.com/cgi/wiki?AbcMetric
+          CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
+
+          def self.calculate(node)
+            new(node).calculate
+          end
+
+          def initialize(node)
+            @assignment = 0
+            @branch = 0
+            @condition = 0
+            @node = node
+          end
+
+          def calculate
+            @node.each_node do |child|
+              if child.assignment?
+                @assignment += 1
+              elsif branch?(child)
+                evaluate_branch_nodes(child)
+              elsif condition?(child)
+                evaluate_condition_node(child)
+              end
+            end
+
+            [
+              Math.sqrt(@assignment**2 + @branch**2 + @condition**2).round(2),
+              "<#{@assignment}, #{@branch}, #{@condition}>"
+            ]
+          end
+
+          def evaluate_branch_nodes(node)
+            if node.comparison_method?
+              @condition += 1
+            else
+              @branch += 1
+            end
+          end
+
+          def evaluate_condition_node(node)
+            @condition += 1 if else_branch?(node)
+            @condition += 1
+          end
+
+          def else_branch?(node)
+            %i[case if].include?(node.type) &&
+              node.else? &&
+              node.loc.else.is?('else')
+          end
+
+          private
+
+          def branch?(node)
+            BRANCH_NODES.include?(node.type)
+          end
+
+          def condition?(node)
+            CONDITION_NODES.include?(node.type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/migration/department_name.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Check that cop names in rubocop:disable comments are given with
+      # department name.
+      class DepartmentName < Cop
+        include RangeHelp
+
+        MSG = 'Department name is missing.'
+
+        def investigate(processed_source)
+          processed_source.each_comment do |comment|
+            next if comment.text !~ /\A(# *rubocop:((dis|en)able|todo) +)(.*)/
+
+            offset = Regexp.last_match(1).length
+            Regexp.last_match(4).scan(%r{[\w/]+|\W+}) do |name|
+              check_cop_name(name, comment, offset)
+              offset += name.length
+            end
+          end
+        end
+
+        def autocorrect(range)
+          shall_warn = false
+          qualified_cop_name = Cop.registry.qualified_cop_name(range.source,
+                                                               nil, shall_warn)
+          ->(corrector) { corrector.replace(range, qualified_cop_name) }
+        end
+
+        private
+
+        def check_cop_name(name, comment, offset)
+          return if name !~ /^[A-Z]/ || name =~ %r{/}
+
+          start = comment.location.expression.begin_pos + offset
+          range = range_between(start, start + name.length)
+          add_offense(range, location: range)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/alignment.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module checks for nodes that should be aligned to the left or right.
+    # This amount is determined by the instance variable @column_delta.
+    module Alignment
+      private
+
+      SPACE = ' '
+
+      attr_reader :column_delta
+
+      def configured_indentation_width
+        cop_config['IndentationWidth'] ||
+          config.for_cop('Layout/IndentationWidth')['Width']
+      end
+
+      def indentation(node)
+        offset(node) + (SPACE * configured_indentation_width)
+      end
+
+      def offset(node)
+        SPACE * node.loc.column
+      end
+
+      def check_alignment(items, base_column = nil)
+        unless items.empty?
+          base_column ||= display_column(items.first.source_range)
+        end
+
+        each_bad_alignment(items, base_column) do |current|
+          expr = current.source_range
+          if offenses.any? { |o| within?(expr, o.location) }
+            # If this offense is within a line range that is already being
+            # realigned by autocorrect, we report the offense without
+            # autocorrecting it. Two rewrites in the same area by the same
+            # cop cannot be handled. The next iteration will find the
+            # offense again and correct it.
+            add_offense(nil, location: expr)
+          else
+            add_offense(current)
+          end
+        end
+      end
+
+      def each_bad_alignment(items, base_column)
+        prev_line = -1
+        items.each do |current|
+          if current.loc.line > prev_line &&
+             begins_its_line?(current.source_range)
+            @column_delta = base_column - display_column(current.source_range)
+
+            yield current if @column_delta.nonzero?
+          end
+          prev_line = current.loc.line
+        end
+      end
+
+      def display_column(range)
+        line = processed_source.lines[range.line - 1]
+        Unicode::DisplayWidth.of(line[0, range.column])
+      end
+
+      def within?(inner, outer)
+        inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
+      end
+
+      def end_of_line_comment(line)
+        processed_source.find_comment { |c| c.loc.line == line }
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/annotation_comment.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Common functionality related to annotation comments.
+      module AnnotationComment
+        private
+
+        def annotation?(comment)
+          _margin, first_word, colon, space, note = split_comment(comment)
+          keyword_appearance?(first_word, colon, space) &&
+            !just_first_word_of_sentence?(first_word, colon, space, note)
+        end
+
+        def split_comment(comment)
+          match = comment.text.match(/^(# ?)([A-Za-z]+)(\s*:)?(\s+)?(\S+)?/)
+          return false unless match
+
+          match.captures
+        end
+
+        def keyword_appearance?(first_word, colon, space)
+          first_word && keyword?(first_word.upcase) && (colon || space)
+        end
+
+        def just_first_word_of_sentence?(first_word, colon, space, note)
+          first_word == first_word.capitalize && !colon && space && note
+        end
+
+        def keyword?(word)
+          config.for_cop('Style/CommentAnnotation')['Keywords'].include?(word)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/array_min_size.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Handles the `MinSize` configuration option for array-based cops
+    # `Style/SymbolArray` and `Style/WordArray`, which check for use of the
+    # relevant percent literal syntax such as `%i[...]` and `%w[...]`
+    module ArrayMinSize
+      private
+
+      def below_array_length?(node)
+        node.values.length < min_size_config
+      end
+
+      def min_size_config
+        cop_config['MinSize']
+      end
+
+      def array_style_detected(style, ary_size)
+        cfg = config_to_allow_offenses
+        return if cfg['Enabled'] == false
+
+        largest_brackets = largest_brackets_size(style, ary_size)
+        smallest_percent = smallest_percent_size(style, ary_size)
+
+        if cfg['EnforcedStyle'] == style.to_s
+          # do nothing
+        elsif cfg['EnforcedStyle'].nil?
+          cfg['EnforcedStyle'] = style.to_s
+        elsif smallest_percent <= largest_brackets
+          self.config_to_allow_offenses = { 'Enabled' => false }
+        else
+          cfg['EnforcedStyle'] = 'percent'
+          cfg['MinSize'] = largest_brackets + 1
+        end
+      end
+
+      def largest_brackets_size(style, ary_size)
+        self.class.largest_brackets ||= -Float::INFINITY
+
+        if style == :brackets && ary_size > self.class.largest_brackets
+          self.class.largest_brackets = ary_size
+        end
+
+        self.class.largest_brackets
+      end
+
+      def smallest_percent_size(style, ary_size)
+        @smallest_percent ||= Float::INFINITY
+
+        if style == :percent && ary_size < @smallest_percent
+          @smallest_percent = ary_size
+        end
+
+        @smallest_percent
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/array_syntax.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common code for ordinary arrays with [] that can be written with %
+    # syntax.
+    module ArraySyntax
+      private
+
+      def bracketed_array_of?(element_type, node)
+        return false unless node.square_brackets? && !node.values.empty?
+
+        node.values.all? { |value| value.type == element_type }
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/check_assignment.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking assignment nodes.
+    module CheckAssignment
+      def on_lvasgn(node)
+        check_assignment(node, extract_rhs(node))
+      end
+      alias on_ivasgn   on_lvasgn
+      alias on_cvasgn   on_lvasgn
+      alias on_gvasgn   on_lvasgn
+      alias on_casgn    on_lvasgn
+      alias on_masgn    on_lvasgn
+      alias on_op_asgn  on_lvasgn
+      alias on_or_asgn  on_lvasgn
+      alias on_and_asgn on_lvasgn
+
+      def on_send(node)
+        rhs = extract_rhs(node)
+
+        return unless rhs
+
+        check_assignment(node, rhs)
+      end
+
+      module_function
+
+      def extract_rhs(node)
+        if node.casgn_type?
+          _scope, _lhs, rhs = *node
+        elsif node.op_asgn_type?
+          _lhs, _op, rhs = *node
+        elsif node.call_type?
+          rhs = node.last_argument
+        elsif node.assignment?
+          _lhs, rhs = *node
+        end
+
+        rhs
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This mixin detects collections that are safe to "break"
+    # by inserting new lines. This is useful for breaking
+    # up long lines.
+    #
+    # Let's look at hashes as an example:
+    #
+    # We know hash keys are safe to break across lines. We can add
+    # linebreaks into hashes on lines longer than the specified maximum.
+    # Then in further passes cops can clean up the multi-line hash.
+    # For example, say the maximum line length is as indicated below:
+    #
+    #                                         |
+    #                                         v
+    # {foo: "0000000000", bar: "0000000000", baz: "0000000000"}
+    #
+    # In a LineLength autocorrection pass, a line is added before
+    # the first key that exceeds the column limit:
+    #
+    # {foo: "0000000000", bar: "0000000000",
+    # baz: "0000000000"}
+    #
+    # In a MultilineHashKeyLineBreaks pass, lines are inserted
+    # before all keys:
+    #
+    # {foo: "0000000000",
+    # bar: "0000000000",
+    # baz: "0000000000"}
+    #
+    # Then in future passes FirstHashElementLineBreak,
+    # MultilineHashBraceLayout, and TrailingCommaInHashLiteral will
+    # manipulate as well until we get:
+    #
+    # {
+    #   foo: "0000000000",
+    #   bar: "0000000000",
+    #   baz: "0000000000",
+    # }
+    #
+    # (Note: Passes may not happen exactly in this sequence.)
+    module CheckLineBreakable
+      def extract_breakable_node(node, max)
+        if node.send_type?
+          args = process_args(node.arguments)
+          return extract_breakable_node_from_elements(node, args, max)
+        elsif node.array_type? || node.hash_type?
+          return extract_breakable_node_from_elements(node, node.children, max)
+        end
+        nil
+      end
+
+      private
+
+      def extract_breakable_node_from_elements(node, elements, max)
+        return unless breakable_collection?(node, elements)
+        return if safe_to_ignore?(node)
+
+        line = processed_source.lines[node.first_line - 1]
+        return if processed_source.commented?(node.loc.begin)
+        return if line.length <= max
+
+        extract_first_element_over_column_limit(node, elements, max)
+      end
+
+      def extract_first_element_over_column_limit(node, elements, max)
+        line = node.first_line
+        i = 0
+        i += 1 while within_column_limit?(elements[i], max, line)
+        return elements.first if i.zero?
+
+        elements[i - 1]
+      end
+
+      def within_column_limit?(element, max, line)
+        element && element.loc.column < max && element.loc.line == line
+      end
+
+      def safe_to_ignore?(node)
+        return true unless max
+        return true if already_on_multiple_lines?(node)
+
+        # If there's a containing breakable collection on the same
+        # line, we let that one get broken first. In a separate pass,
+        # this one might get broken as well, but to avoid conflicting
+        # or redundant edits, we only mark one offense at a time.
+        return true if contained_by_breakable_collection_on_same_line?(node)
+
+        if contained_by_multiline_collection_that_could_be_broken_up?(node)
+          return true
+        end
+
+        false
+      end
+
+      def breakable_collection?(node, elements)
+        # For simplicity we only want to insert breaks in normal
+        # hashes wrapped in a set of curly braces like {foo: 1}.
+        # That is, not a kwargs hash. For method calls, this ensures
+        # the method call is made with parens.
+        starts_with_bracket = node.loc.begin
+
+        # If the call has a second argument, we can insert a line
+        # break before the second argument and the rest of the
+        # argument will get auto-formatted onto separate lines
+        # by other cops.
+        has_second_element = elements.length >= 2
+
+        starts_with_bracket && has_second_element
+      end
+
+      def contained_by_breakable_collection_on_same_line?(node)
+        node.each_ancestor.find do |ancestor|
+          # Ignore ancestors on different lines.
+          break if ancestor.first_line != node.first_line
+
+          if ancestor.hash_type? || ancestor.array_type?
+            elements = ancestor.children
+          elsif ancestor.send_type?
+            elements = process_args(ancestor.arguments)
+          else
+            next
+          end
+
+          return true if breakable_collection?(ancestor, elements)
+        end
+
+        false
+      end
+
+      def contained_by_multiline_collection_that_could_be_broken_up?(node)
+        node.each_ancestor.find do |ancestor|
+          if ancestor.hash_type? || ancestor.array_type?
+            if breakable_collection?(ancestor, ancestor.children)
+              return children_could_be_broken_up?(ancestor.children)
+            end
+          end
+
+          next unless ancestor.send_type?
+
+          args = process_args(ancestor.arguments)
+          if breakable_collection?(ancestor, args)
+            return children_could_be_broken_up?(args)
+          end
+        end
+
+        false
+      end
+
+      def children_could_be_broken_up?(children)
+        return false if all_on_same_line?(children)
+
+        last_seen_line = -1
+        children.each do |child|
+          return true if last_seen_line >= child.first_line
+
+          last_seen_line = child.last_line
+        end
+        false
+      end
+
+      def all_on_same_line?(nodes)
+        return true if nodes.empty?
+
+        nodes.first.first_line == nodes.last.last_line
+      end
+
+      def process_args(args)
+        # If there is a trailing hash arg without explicit braces, like this:
+        #
+        #    method(1, 'key1' => value1, 'key2' => value2)
+        #
+        # ...then each key/value pair is treated as a method 'argument'
+        # when determining where line breaks should appear.
+        if (last_arg = args.last)
+          if last_arg.hash_type? && !last_arg.braces?
+            args = args.concat(args.pop.children)
+          end
+        end
+        args
+      end
+
+      def already_on_multiple_lines?(node)
+        node.first_line != node.last_line
+      end
+    end
+  end
+end