rubbycop 0.49.0

data/lib/rubbycop/cop/metrics/method_length.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Metrics
+      # This cop checks if the length of a method exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      class MethodLength < Cop
+        include OnMethodDef
+        include TooManyLines
+
+        LABEL = 'Method'.freeze
+
+        private
+
+        def on_method_def(node, _method_name, _args, _body)
+          check_code_length(node)
+        end
+
+        def cop_label
+          LABEL
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/metrics/module_length.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Metrics
+      # This cop checks if the length a module exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      class ModuleLength < Cop
+        include ClassishLength
+
+        def on_module(node)
+          check_code_length(node)
+        end
+
+        private
+
+        def message(length, max_length)
+          format('Module has too many lines. [%d/%d]', length, max_length)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/metrics/parameter_lists.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Metrics
+      # This cop checks for methods with too many parameters.
+      # The maximum number of parameters is configurable.
+      # On Ruby 2.0+ keyword arguments can optionally
+      # be excluded from the total count.
+      class ParameterLists < Cop
+        include ConfigurableMax
+
+        MSG = 'Avoid parameter lists longer than %d parameters. [%d/%d]'.freeze
+
+        def on_args(node)
+          count = args_count(node)
+          return unless count > max_params
+
+          message = format(MSG, max_params, count, max_params)
+          add_offense(node, :expression, message) do
+            self.max = count
+          end
+        end
+
+        private
+
+        def args_count(node)
+          if count_keyword_args?
+            node.children.size
+          else
+            node.children.count { |a| !%i[kwoptarg kwarg].include?(a.type) }
+          end
+        end
+
+        def max_params
+          cop_config['Max']
+        end
+
+        def count_keyword_args?
+          cop_config['CountKeywordArgs']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 %s is too high. [%d/%d]'.freeze
+        COUNTED_NODES = %i[if case while until
+                           for rescue and or].freeze
+
+        private
+
+        def complexity_score_for(node)
+          case node.type
+          when :case
+            expression, *whens, _else = *node
+            # 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 expression.nil?
+              whens.length
+            else
+              # Otherwise, the case node gets 0.8 complexity points and each
+              # when gets 0.2.
+              (0.8 + 0.2 * whens.length).round
+            end
+          when :if
+            node.else? && !node.elsif? ? 2 : 1
+          else
+            1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/access_modifier_node.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking modifier nodes.
+    module AccessModifierNode
+      extend NodePattern::Macros
+
+      def_node_matcher :private_node?, '(send nil :private)'
+      def_node_matcher :protected_node?, '(send nil :protected)'
+      def_node_matcher :public_node?, '(send nil :public)'
+      def_node_matcher :module_function_node?, '(send nil :module_function)'
+
+      # Returns true when the node is an access modifier.
+      def modifier_node?(node)
+        modifier_structure?(node) && class_or_module_parent?(node)
+      end
+
+      # Returns true when the node looks like an access modifier.
+      def modifier_structure?(node)
+        private_node?(node) ||
+          protected_node?(node) ||
+          public_node?(node) ||
+          module_function_node?(node)
+      end
+
+      # Returns true when the parent of what looks like an access modifier
+      # is a Class or Module. Filters out simple method calls to similarly
+      # named private, protected or public.
+      def class_or_module_parent?(node)
+        node.each_ancestor do |ancestor|
+          if ancestor.block_type?
+            return true if ancestor.class_constructor?
+          elsif !ancestor.begin_type?
+            return %i[casgn sclass class module].include?(ancestor.type)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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/rubbycop/cop/mixin/array_hash_indentation.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common code for indenting literal arrays and hashes.
+    module ArrayHashIndentation
+      def each_argument_node(node, type)
+        left_parenthesis = node.loc.begin
+
+        return unless left_parenthesis
+
+        node.arguments.each do |arg|
+          on_node(type, arg, :send) do |type_node|
+            left_brace = type_node.loc.begin
+            if left_brace && left_brace.line == left_parenthesis.line
+              yield type_node, left_parenthesis
+              ignore_node(type_node)
+            end
+          end
+        end
+      end
+
+      def check_first(first, left_brace, left_parenthesis, offset)
+        actual_column = first.source_range.column
+        expected_column = base_column(left_brace, left_parenthesis) +
+                          configured_indentation_width + offset
+        @column_delta = expected_column - actual_column
+        styles =
+          detected_styles(actual_column, offset, left_parenthesis, left_brace)
+
+        if @column_delta.zero?
+          check_expected_style(styles)
+        else
+          incorrect_style_detected(styles, first, left_parenthesis)
+        end
+      end
+
+      def check_expected_style(styles)
+        if styles.size > 1
+          ambiguous_style_detected(*styles)
+        else
+          correct_style_detected
+        end
+      end
+
+      def base_column(left_brace, left_parenthesis)
+        if style == brace_alignment_style
+          left_brace.column
+        elsif left_parenthesis && style == :special_inside_parentheses
+          left_parenthesis.column + 1
+        else
+          left_brace.source_line =~ /\S/
+        end
+      end
+
+      def detected_styles(actual_column, offset, left_parenthesis, left_brace)
+        base_column = actual_column - configured_indentation_width - offset
+        detected_styles_for_column(base_column, left_parenthesis, left_brace)
+      end
+
+      def detected_styles_for_column(column, left_parenthesis, left_brace)
+        styles = []
+        if column == (left_brace.source_line =~ /\S/)
+          styles << :consistent
+          styles << :special_inside_parentheses unless left_parenthesis
+        end
+        if left_parenthesis && column == left_parenthesis.column + 1
+          styles << :special_inside_parentheses
+        end
+        styles << brace_alignment_style if column == left_brace.column
+        styles
+      end
+
+      def incorrect_style_detected(styles, first, left_parenthesis)
+        add_offense(first, :expression,
+                    message(base_description(left_parenthesis))) do
+          ambiguous_style_detected(*styles)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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/rubbycop/cop/mixin/array_syntax.rb

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

data/lib/rubbycop/cop/mixin/autocorrect_alignment.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # This module does auto-correction of nodes that should just be moved to
+    # the left or to the right, amount being determined by the instance
+    # variable @column_delta.
+    module AutocorrectAlignment
+      SPACE = ' '.freeze
+
+      def configured_indentation_width
+        cop_config['IndentationWidth'] ||
+          config.for_cop('IndentationWidth')['Width']
+      end
+
+      def indentation(node)
+        offset(node) + (SPACE * configured_indentation_width)
+      end
+
+      def offset(node)
+        SPACE * node.loc.column
+      end
+
+      def display_column(range)
+        line = processed_source.lines[range.line - 1]
+        Unicode::DisplayWidth.of(line[0, range.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 can not be handled. The next iteration will find the
+            # offense again and correct it.
+            add_offense(nil, expr)
+          else
+            add_offense(current, :expression)
+          end
+        end
+      end
+
+      def autocorrect(arg)
+        return unless arg
+
+        heredoc_ranges = heredoc_ranges(arg)
+        expr = arg.respond_to?(:loc) ? arg.loc.expression : arg
+
+        # We can't use the instance variable inside the lambda. That would just
+        # give each lambda the same reference and they would all get the last
+        # value of @column_delta. A local variable fixes the problem.
+        column_delta = @column_delta
+
+        return if block_comment_within?(expr)
+
+        lambda do |corrector|
+          each_line(expr) do |line_begin_pos|
+            autocorrect_line(corrector, line_begin_pos, expr, column_delta,
+                             heredoc_ranges)
+          end
+        end
+      end
+
+      private
+
+      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 autocorrect_line(corrector, line_begin_pos, expr, column_delta,
+                           heredoc_ranges)
+        range = calculate_range(expr, line_begin_pos, column_delta)
+        # We must not change indentation of heredoc strings.
+        return if heredoc_ranges.any? { |h| within?(range, h) }
+
+        if column_delta > 0
+          unless range.source == "\n"
+            corrector.insert_before(range, ' ' * column_delta)
+          end
+        elsif range.source =~ /\A[ \t]+\z/
+          remove(range, corrector)
+        end
+      end
+
+      def heredoc_ranges(arg)
+        return [] unless arg.is_a?(Parser::AST::Node)
+
+        arg.each_node(:dstr)
+           .select { |n| n.loc.respond_to?(:heredoc_body) }
+           .map { |n| n.loc.heredoc_body.join(n.loc.heredoc_end) }
+      end
+
+      def block_comment_within?(expr)
+        processed_source.comments.select(&:document?).any? do |c|
+          within?(c.loc.expression, expr)
+        end
+      end
+
+      def within?(inner, outer)
+        inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
+      end
+
+      def calculate_range(expr, line_begin_pos, column_delta)
+        starts_with_space = expr.source_buffer.source[line_begin_pos] =~ / /
+        pos_to_remove = if column_delta > 0 || starts_with_space
+                          line_begin_pos
+                        else
+                          line_begin_pos - column_delta.abs
+                        end
+
+        range_between(pos_to_remove, pos_to_remove + column_delta.abs)
+      end
+
+      def remove(range, corrector)
+        original_stderr = $stderr
+        $stderr = StringIO.new # Avoid error messages on console
+        corrector.remove(range)
+      rescue RuntimeError
+        range = range_between(range.begin_pos + 1, range.end_pos + 1)
+        retry if range.source =~ /^ +$/
+      ensure
+        $stderr = original_stderr
+      end
+
+      def each_line(expr)
+        line_begin_pos = expr.begin_pos
+        expr.source.each_line do |line|
+          yield line_begin_pos
+          line_begin_pos += line.length
+        end
+      end
+    end
+  end
+end