rubbycop 0.49.0

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking assignment nodes.
+    module CheckAssignment
+      Util::ASGN_NODES.each do |type|
+        define_method("on_#{type}") do |node|
+          check_assignment(node, extract_rhs(node))
+        end
+      end
+
+      def on_send(node)
+        return unless node.setter_method?
+
+        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 Util::ASGN_NODES.include?(node.type)
+          _lhs, rhs = *node
+        elsif node.send_type?
+          rhs = node.last_argument
+        end
+
+        rhs
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking length of classes and modules.
+    module ClassishLength
+      include CodeLength
+
+      private
+
+      def code_length(node)
+        body_line_numbers = line_range(node).to_a[1...-1]
+
+        target_line_numbers = body_line_numbers -
+                              line_numbers_of_inner_nodes(node, :module, :class)
+
+        target_line_numbers.reduce(0) do |length, line_number|
+          source_line = processed_source[line_number]
+          next length if irrelevant_line(source_line)
+          length + 1
+        end
+      end
+
+      def line_numbers_of_inner_nodes(node, *types)
+        line_numbers = Set.new
+
+        node.each_descendant(*types) do |inner_node|
+          line_range = line_range(inner_node)
+          line_numbers.merge(line_range)
+        end
+
+        line_numbers.to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking length of code segments.
+    module CodeLength
+      include ConfigurableMax
+
+      def max_length
+        cop_config['Max']
+      end
+
+      def count_comments?
+        cop_config['CountComments']
+      end
+
+      def check_code_length(node)
+        length = code_length(node)
+        return unless length > max_length
+
+        add_offense(node, :expression, message(length, max_length)) do
+          self.max = length
+        end
+      end
+
+      # Returns true for lines that shall not be included in the count.
+      def irrelevant_line(source_line)
+        source_line.blank? || !count_comments? && comment_line?(source_line)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Handles `EnforcedStyle` configuration parameters.
+    module ConfigurableEnforcedStyle
+      def opposite_style_detected
+        style_detected(alternative_style)
+      end
+
+      def correct_style_detected
+        style_detected(style)
+      end
+
+      def unexpected_style_detected(unexpected)
+        style_detected(unexpected)
+      end
+
+      def ambiguous_style_detected(*possibilities)
+        style_detected(possibilities)
+      end
+
+      def style_detected(detected)
+        return if no_acceptable_style?
+
+        # `detected` can be a single style, or an Array of possible styles
+        # (if there is more than one which matches the observed code)
+        detected_as_strings = Array(detected).map(&:to_s)
+
+        updated_list = if detected_style
+                         detected_style & detected_as_strings
+                       else
+                         # We haven't observed any specific style yet.
+                         detected_as_strings
+                       end
+        if updated_list.empty?
+          no_acceptable_style!
+        else
+          self.detected_style = updated_list
+          config_to_allow_offenses[style_parameter_name] = updated_list.first
+        end
+      end
+
+      def no_acceptable_style?
+        config_to_allow_offenses['Enabled'] == false
+      end
+
+      def no_acceptable_style!
+        self.config_to_allow_offenses = { 'Enabled' => false }
+      end
+
+      def detected_style
+        Formatter::DisabledConfigFormatter.detected_styles[cop_name] ||= nil
+      end
+
+      def detected_style=(style)
+        Formatter::DisabledConfigFormatter.detected_styles[cop_name] = style
+      end
+
+      alias conflicting_styles_detected no_acceptable_style!
+      alias unrecognized_style_detected no_acceptable_style!
+
+      def style
+        @enforced_style ||= begin
+          s = cop_config[style_parameter_name].to_sym
+          unless supported_styles.include?(s)
+            raise "Unknown style #{s} selected!"
+          end
+          s
+        end
+      end
+
+      def alternative_style
+        if supported_styles.size != 2
+          raise 'alternative_style can only be used when there are exactly ' \
+               '2 SupportedStyles'
+        end
+        alternative_styles.first
+      end
+
+      def alternative_styles
+        (supported_styles - [style])
+      end
+
+      def supported_styles
+        @supported_styles ||= begin
+          supported_styles = Util.to_supported_styles(style_parameter_name)
+          cop_config[supported_styles].map(&:to_sym)
+        end
+      end
+
+      def style_parameter_name
+        'EnforcedStyle'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Shared functionality between mixins that enforce naming conventions
+    module ConfigurableFormatting
+      include ConfigurableEnforcedStyle
+
+      def check_name(node, name, name_range)
+        return if operator?(name)
+
+        if valid_name?(node, name)
+          correct_style_detected
+        else
+          add_offense(node, name_range, message(style)) do
+            report_opposing_styles(node, name)
+          end
+        end
+      end
+
+      def report_opposing_styles(node, name)
+        alternative_styles.each do |alternative|
+          if valid_name?(node, name, alternative)
+            return unexpected_style_detected(alternative)
+          end
+        end
+      end
+
+      def valid_name?(node, name, given_style = style)
+        name.match(self.class::FORMATS.fetch(given_style)) ||
+          class_emitter_method?(node, name)
+      end
+
+      # A class emitter method is a singleton method in a class/module, where
+      # the method has the same name as a class defined in the class/module.
+      def class_emitter_method?(node, name)
+        return false unless node.parent && node.defs_type?
+        # a class emitter method may be defined inside `def self.included`,
+        # `def self.extended`, etc.
+        node = node.parent while node.parent.defs_type?
+
+        node.parent.each_child_node(:class).any? do |c|
+          c.loc.name.is?(name.to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Handles `Max` configuration parameters, especially setting them to an
+    # appropriate value with --auto-gen-config.
+    module ConfigurableMax
+      def max=(value)
+        cfg = config_to_allow_offenses
+        value = [cfg[max_parameter_name], value].max if cfg[max_parameter_name]
+        cfg[max_parameter_name] = value
+      end
+
+      def max_parameter_name
+        'Max'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # This module provides functionality for checking if names match the
+    # configured EnforcedStyle.
+    module ConfigurableNaming
+      include ConfigurableFormatting
+
+      FORMATS = {
+        snake_case: /^@{0,2}[\da-z_]+[!?=]?$/,
+        camelCase:  /^@{0,2}_?[a-z][\da-zA-Z]+[!?=]?$/
+      }.freeze
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # This module provides functionality for checking if numbering match the
+    # configured EnforcedStyle.
+    module ConfigurableNumbering
+      include ConfigurableFormatting
+
+      FORMATS = {
+        snake_case:  /(?:[a-z_]|_\d+)$/,
+        normalcase:  /(?:_\D*|[A-Za-z]\d*)$/,
+        non_integer: /[A-Za-z_]$/
+      }.freeze
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking if nodes.
+    module DefNode
+      extend NodePattern::Macros
+
+      NON_PUBLIC_MODIFIERS = %w[private protected].freeze
+
+      def non_public?(node)
+        non_public_modifier?(node.parent) ||
+          preceding_non_public_modifier?(node)
+      end
+
+      def preceding_non_public_modifier?(node)
+        stripped_source_upto(node.loc.line).any? do |line|
+          NON_PUBLIC_MODIFIERS.include?(line)
+        end
+      end
+
+      def_node_matcher :non_public_modifier?, <<-PATTERN
+        (send nil {:private :protected} ({def defs} ...))
+      PATTERN
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking documentation.
+    module DocumentationComment
+      extend NodePattern::Macros
+      include Style::AnnotationComment
+
+      def_node_matcher :constant_definition?, '{class module casgn}'
+
+      private
+
+      def documentation_comment?(node)
+        preceding_lines = preceding_lines(node)
+
+        return false unless preceding_comment?(node, preceding_lines.last)
+
+        preceding_lines.any? do |comment|
+          !annotation?(comment) &&
+            !interpreter_directive_comment?(comment) &&
+            !rubbycop_directive_comment?(comment)
+        end
+      end
+
+      def preceding_comment?(n1, n2)
+        n1 && n2 && preceed?(n2, n1) &&
+          comment_line?(n2.loc.expression.source)
+      end
+
+      def preceding_lines(node)
+        processed_source.ast_with_comments[node].select do |line|
+          line.loc.line < node.loc.line
+        end
+      end
+
+      def interpreter_directive_comment?(comment)
+        comment.text =~ /^#\s*(frozen_string_literal|encoding):/
+      end
+
+      def rubbycop_directive_comment?(comment)
+        comment.text =~ CommentConfig::COMMENT_DIRECTIVE_REGEXP
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for dealing with duplication.
+    module Duplication
+      private
+
+      # Whether the `collection` contains any duplicates.
+      #
+      # @param [Array] collection an array to check for duplicates
+      # @return [Boolean] whether the array contains any duplicates
+      def duplicates?(collection)
+        collection.size > 1 && collection.size > collection.uniq.size
+      end
+
+      # Returns all duplicates, including the first instance of the duplicated
+      # elements.
+      #
+      # @param [Array] collection an array to return duplicates for
+      # @return [Array] all the duplicates
+      def duplicates(collection)
+        grouped_duplicates(collection).flatten
+      end
+
+      # Returns the consecutive duplicates, leaving out the first instance of
+      # the duplicated elements.
+      #
+      # @param [Array] collection an array to return consecutive duplicates for
+      # @return [Array] the consecutive duplicates
+      def consecutive_duplicates(collection)
+        grouped_duplicates(collection).flat_map { |items| items[1..-1] }
+      end
+
+      # Returns a hash of grouped duplicates. The key will be the first
+      # instance of the element, and  the value an `array` of the initial
+      # element and all duplicate instances.
+      #
+      # @param [Array] collection an array to group duplicates for
+      # @return [Array] the grouped duplicates
+      def grouped_duplicates(collection)
+        collection.group_by { |item| item }.values.reject(&:one?)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Common functionality for checking if presence/absence of empty lines
+      # around some kind of body matches the configuration.
+      module EmptyLinesAroundBody
+        extend NodePattern::Macros
+        include ConfigurableEnforcedStyle
+
+        MSG_EXTRA = 'Extra empty line detected at %s body %s.'.freeze
+        MSG_MISSING = 'Empty line missing at %s body %s.'.freeze
+        MSG_DEFERRED = 'Empty line missing before first %s definition'.freeze
+
+        def_node_matcher :constant_definition?, '{class module}'
+        def_node_matcher :empty_line_required?, '{def defs class module}'
+
+        def autocorrect(args)
+          offense_style, range = args
+          lambda do |corrector|
+            case offense_style
+            when :no_empty_lines then
+              corrector.remove(range)
+            when :empty_lines then
+              corrector.insert_before(range, "\n")
+            end
+          end
+        end
+
+        private
+
+        def check(node, body)
+          # When style is `empty_lines`, if the body is empty, we don't enforce
+          # the presence OR absence of an empty line
+          # But if style is `no_empty_lines`, there must not be an empty line
+          return unless body || style == :no_empty_lines
+          return if node.single_line?
+
+          first_line = node.source_range.first_line
+          last_line = node.source_range.last_line
+
+          case style
+          when :empty_lines_except_namespace
+            check_empty_lines_except_namespace(body, first_line, last_line)
+          when :empty_lines_special
+            check_empty_lines_special(body, first_line, last_line)
+          else
+            check_both(style, first_line, last_line)
+          end
+        end
+
+        def check_empty_lines_except_namespace(body, first_line, last_line)
+          if namespace?(body, with_one_child: true)
+            check_both(:no_empty_lines, first_line, last_line)
+          else
+            check_both(:empty_lines, first_line, last_line)
+          end
+        end
+
+        def check_empty_lines_special(body, first_line, last_line)
+          return unless body
+          if namespace?(body, with_one_child: true)
+            check_both(:no_empty_lines, first_line, last_line)
+          else
+            if first_child_requires_empty_line?(body)
+              check_beginning(:empty_lines, first_line)
+            else
+              check_beginning(:no_empty_lines, first_line)
+              check_deferred_empty_line(body)
+            end
+            check_ending(:empty_lines, last_line)
+          end
+        end
+
+        def check_both(style, first_line, last_line)
+          check_beginning(style, first_line)
+          check_ending(style, last_line)
+        end
+
+        def check_beginning(style, first_line)
+          check_source(style, first_line, 'beginning')
+        end
+
+        def check_ending(style, last_line)
+          check_source(style, last_line - 2, 'end')
+        end
+
+        def check_source(style, line_no, desc)
+          case style
+          when :no_empty_lines
+            check_line(style, line_no, message(MSG_EXTRA, desc), &:empty?)
+          when :empty_lines
+            check_line(style, line_no, message(MSG_MISSING, desc)) do |line|
+              !line.empty?
+            end
+          end
+        end
+
+        def check_line(style, line, msg)
+          return unless yield(processed_source.lines[line])
+
+          offset = style == :empty_lines && msg.include?('end.') ? 2 : 1
+          range = source_range(processed_source.buffer, line + offset, 0)
+          add_offense([style, range], range, msg)
+        end
+
+        def check_deferred_empty_line(body)
+          node = first_empty_line_required_child(body)
+          return unless node
+
+          line = previous_line_ignoring_comments(node.loc.first_line)
+          return if processed_source[line].empty?
+
+          range = source_range(processed_source.buffer, line + 2, 0)
+          add_offense([:empty_lines, range], range, deferred_message(node))
+        end
+
+        def namespace?(body, with_one_child: false)
+          if body.begin_type?
+            return false if with_one_child
+            body.children.all? { |child| constant_definition?(child) }
+          else
+            constant_definition?(body)
+          end
+        end
+
+        def first_child_requires_empty_line?(body)
+          if body.begin_type?
+            empty_line_required?(body.children.first)
+          else
+            empty_line_required?(body)
+          end
+        end
+
+        def first_empty_line_required_child(body)
+          if body.begin_type?
+            body.children.find { |child| empty_line_required?(child) }
+          elsif empty_line_required?(body)
+            body
+          end
+        end
+
+        def previous_line_ignoring_comments(send_line)
+          (send_line - 2).downto(0) do |line|
+            return line unless comment_line?(processed_source[line])
+          end
+          0
+        end
+
+        def message(type, desc)
+          format(type, self.class::KIND, desc)
+        end
+
+        def deferred_message(node)
+          format(MSG_DEFERRED, node.type)
+        end
+      end
+    end
+  end
+end