rubocop 0.87.1

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to allow certain methods when
+    # parsing.
+    module AllowedMethods
+      private
+
+      def allowed_method?(name)
+        allowed_methods.include?(name.to_s)
+      end
+
+      def allowed_methods
+        cop_config.fetch('AllowedMethods', [])
+      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,57 @@
+# 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
+
+        @smallest_percent = ary_size if style == :percent && ary_size < @smallest_percent
+
+        @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/auto_corrector.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # extend this module to signal autocorrection support
+    module AutoCorrector
+      def support_autocorrect?
+        true
+      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,184 @@
+# 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)
+
+        return true if contained_by_multiline_collection_that_could_be_broken_up?(node)
+
+        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)
+          return children_could_be_broken_up?(args) if breakable_collection?(ancestor, args)
+        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)
+          args = args.concat(args.pop.children) if last_arg.hash_type? && !last_arg.braces?
+        end
+        args
+      end
+
+      def already_on_multiple_lines?(node)
+        node.first_line != node.last_line
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking length of code segments.
+    module CodeLength
+      include ConfigurableMax
+
+      private
+
+      def max_length
+        cop_config['Max']
+      end
+
+      def count_comments?
+        cop_config['CountComments']
+      end
+
+      def count_as_one
+        Array(cop_config['CountAsOne']).map(&:to_sym)
+      end
+
+      def check_code_length(node)
+        length = code_length(node)
+
+        return unless length > max_length
+
+        location = node.casgn_type? ? :name : :expression
+
+        add_offense(node, location: location,
+                          message: 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/rubocop/cop/mixin/configurable_enforced_style.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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_configured?
+        cop_config.key?(style_parameter_name)
+      end
+
+      def style
+        @style ||= begin
+          s = cop_config[style_parameter_name].to_sym
+          raise "Unknown style #{s} selected!" unless supported_styles.include?(s)
+
+          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