rubocop 0.75.1

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

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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/rubocop/cop/mixin/code_length.rb

@@ -0,0 +1,38 @@
+# 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 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,98 @@
+# 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
+        @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/rubocop/cop/mixin/configurable_formatting.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Shared functionality between mixins that enforce naming conventions
+    module ConfigurableFormatting
+      include ConfigurableEnforcedStyle
+
+      def check_name(node, name, name_range)
+        if valid_name?(node, name)
+          correct_style_detected
+        else
+          add_offense(node, location: name_range, message: 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