rubocop 0.75.1

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for enforcing a specific superclass
+    module EnforceSuperclass
+      def self.included(base)
+        base.def_node_matcher :class_definition, <<~PATTERN
+          (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
+        PATTERN
+
+        base.def_node_matcher :class_new_definition, <<~PATTERN
+          [!^(casgn nil? :#{base::SUPERCLASS} ...) (send (const nil? :Class) :new #{base::BASE_PATTERN})]
+        PATTERN
+      end
+
+      def on_class(node)
+        class_definition(node) do
+          add_offense(node.children[1])
+        end
+      end
+
+      def on_send(node)
+        class_new_definition(node) do
+          add_offense(node.children.last)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking for a line break before the first
+    # element in a multi-line collection.
+    module FirstElementLineBreak
+      private
+
+      def check_method_line_break(node, children)
+        return if children.empty?
+
+        return unless method_uses_parens?(node, children.first)
+
+        check_children_line_break(node, children)
+      end
+
+      def method_uses_parens?(node, limit)
+        source = node.source_range.source_line[0...limit.loc.column]
+        source =~ /\s*\(\s*$/
+      end
+
+      def check_children_line_break(node, children, start = node)
+        return if children.size < 2
+
+        line = start.first_line
+
+        min = first_by_line(children)
+        return if line != min.first_line
+
+        max = last_by_line(children)
+        return if line == max.last_line
+
+        add_offense(min)
+      end
+
+      def first_by_line(nodes)
+        nodes.min_by(&:first_line)
+      end
+
+      def last_by_line(nodes)
+        nodes.max_by(&:last_line)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for dealing with frozen string literals.
+    module FrozenStringLiteral
+      module_function
+
+      FROZEN_STRING_LITERAL = '# frozen_string_literal:'
+      FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'
+      FROZEN_STRING_LITERAL_TYPES = %i[str dstr].freeze
+
+      def frozen_string_literal_comment_exists?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).valid_literal_value?
+        end
+      end
+
+      private
+
+      def frozen_string_literals_enabled?
+        ruby_version = processed_source.ruby_version
+        return false unless ruby_version
+
+        # TODO: Ruby officially abandon making frozen string literals default
+        # for Ruby 3.0.
+        # https://bugs.ruby-lang.org/issues/11473#note-53
+        # Whether frozen string literals will be the default after Ruby 3.0
+        # or not is still unclear as of January 2019.
+        # It may be necessary to add this code in the future.
+        #
+        #   return true if ruby_version >= 3.1
+        #
+        # And the above `ruby_version >= 3.1` is undecided whether it will be
+        # Ruby 3.1, 3.2, 4.0 or others.
+        # See https://bugs.ruby-lang.org/issues/8976#note-41 for details.
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal?
+        end
+      end
+
+      def leading_comment_lines
+        comments = processed_source.comments
+
+        comments.each_with_object([]) do |comment, leading_comments|
+          next if comment.loc.line > 3
+
+          leading_comments << comment.text
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking hash alignment.
+    module HashAlignment
+      # Handles calculation of deltas when the enforced style is 'key'.
+      class KeyAlignment
+        def checkable_layout?(_node)
+          true
+        end
+
+        def deltas_for_first_pair(first_pair, _node)
+          {
+            separator: separator_delta(first_pair),
+            value: value_delta(first_pair)
+          }
+        end
+
+        def deltas(first_pair, current_pair)
+          if Util.begins_its_line?(current_pair.source_range)
+            key_delta = first_pair.key_delta(current_pair)
+            separator_delta = separator_delta(current_pair)
+            value_delta = value_delta(current_pair)
+
+            { key: key_delta, separator: separator_delta, value: value_delta }
+          else
+            {}
+          end
+        end
+
+        private
+
+        def separator_delta(pair)
+          if pair.hash_rocket?
+            correct_separator_column = pair.key.loc.expression.end.column + 1
+            actual_separator_column = pair.loc.operator.column
+
+            correct_separator_column - actual_separator_column
+          else
+            0
+          end
+        end
+
+        def value_delta(pair)
+          return 0 if pair.kwsplat_type? || pair.value_on_new_line?
+
+          correct_value_column = pair.loc.operator.end.column + 1
+          actual_value_column = pair.value.loc.column
+
+          correct_value_column - actual_value_column
+        end
+      end
+
+      # Common functionality for checking alignment of hash values.
+      module ValueAlignment
+        def checkable_layout?(node)
+          !node.pairs_on_same_line? && !node.mixed_delimiters?
+        end
+
+        def deltas(first_pair, current_pair)
+          key_delta = key_delta(first_pair, current_pair)
+          separator_delta = separator_delta(first_pair, current_pair,
+                                            key_delta)
+          value_delta = value_delta(first_pair, current_pair) -
+                        key_delta - separator_delta
+
+          { key: key_delta, separator: separator_delta, value: value_delta }
+        end
+
+        private
+
+        def separator_delta(first_pair, current_pair, key_delta)
+          if current_pair.hash_rocket?
+            hash_rocket_delta(first_pair, current_pair) - key_delta
+          else
+            0
+          end
+        end
+      end
+
+      # Handles calculation of deltas when the enforced style is 'table'.
+      class TableAlignment
+        include ValueAlignment
+
+        def initialize
+          self.max_key_width = 0
+        end
+
+        def deltas_for_first_pair(first_pair, node)
+          self.max_key_width = node.keys.map { |key| key.source.length }.max
+
+          separator_delta = separator_delta(first_pair, first_pair, 0)
+          {
+            separator: separator_delta,
+            value: value_delta(first_pair, first_pair) - separator_delta
+          }
+        end
+
+        private
+
+        attr_accessor :max_key_width
+
+        def key_delta(first_pair, current_pair)
+          first_pair.key_delta(current_pair)
+        end
+
+        def hash_rocket_delta(first_pair, current_pair)
+          first_pair.loc.column + max_key_width + 1 -
+            current_pair.loc.operator.column
+        end
+
+        def value_delta(first_pair, current_pair)
+          return 0 if current_pair.kwsplat_type?
+
+          correct_value_column = first_pair.key.loc.column +
+                                 current_pair.delimiter(true).length +
+                                 max_key_width
+          correct_value_column - current_pair.value.loc.column
+        end
+      end
+
+      # Handles calculation of deltas when the enforced style is 'separator'.
+      class SeparatorAlignment
+        include ValueAlignment
+
+        def deltas_for_first_pair(*_nodes)
+          {}
+        end
+
+        private
+
+        def key_delta(first_pair, current_pair)
+          first_pair.key_delta(current_pair, :right)
+        end
+
+        def hash_rocket_delta(first_pair, current_pair)
+          first_pair.delimiter_delta(current_pair)
+        end
+
+        def value_delta(first_pair, current_pair)
+          first_pair.value_delta(current_pair)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for working with heredoc strings.
+    module Heredoc
+      OPENING_DELIMITER = /(<<[~-]?)['"`]?([^'"`]+)['"`]?/.freeze
+
+      def on_str(node)
+        return unless node.heredoc?
+
+        on_heredoc(node)
+      end
+      alias on_dstr on_str
+      alias on_xstr on_str
+
+      def on_heredoc(_node)
+        raise NotImplementedError
+      end
+
+      private
+
+      def delimiter_string(node)
+        node.source.match(OPENING_DELIMITER).captures[1]
+      end
+
+      def heredoc_type(node)
+        node.source.match(OPENING_DELIMITER).captures[0]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to ignore certain methods when
+    # parsing.
+    module IgnoredMethods
+      private
+
+      def ignored_method?(name)
+        ignored_methods.include?(name.to_s)
+      end
+
+      def ignored_methods
+        cop_config.fetch('IgnoredMethods', [])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to ignore certain lines when
+    # parsing.
+    module IgnoredPattern
+      private
+
+      def ignored_line?(line)
+        line = if line.respond_to?(:source_line)
+                 line.source_line
+               elsif line.respond_to?(:node)
+                 line.node.source_range.source_line
+               end
+
+        matches_ignored_pattern?(line)
+      end
+
+      def matches_ignored_pattern?(line)
+        ignored_patterns.any? { |pattern| Regexp.new(pattern).match(line) }
+      end
+
+      def ignored_patterns
+        cop_config['IgnoredPatterns'] || []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking integer nodes.
+    module IntegerNode
+      private
+
+      def integer_part(node)
+        node.source.sub(/^[+-]/, '').split(/[eE.]/, 2).first
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for working with string interpolations.
+    #
+    # @abstract Subclasses are expected to implement {#on_interpolation}.
+    module Interpolation
+      def on_dstr(node)
+        on_node_with_interpolations(node)
+      end
+
+      alias on_xstr on_dstr
+      alias on_dsym on_dstr
+      alias on_regexp on_dstr
+
+      def on_node_with_interpolations(node)
+        node.each_child_node(:begin) do |begin_node|
+          on_interpolation(begin_node)
+        end
+      end
+
+      # @!method on_interpolation(begin_node)
+      #   Inspect the `:begin` node of an interpolation
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for obtaining source ranges from regexp matches
+    module MatchRange
+      include RangeHelp
+
+      private
+
+      # Return a new `Range` covering the first matching group number for each
+      # match of `regex` inside `range`
+      def each_match_range(range, regex)
+        range.source.scan(regex) do
+          yield match_range(range, Regexp.last_match)
+        end
+      end
+
+      # For a `match` inside `range`, return a new `Range` covering the match
+      def match_range(range, match)
+        range_between(range.begin_pos + match.begin(1),
+                      range.begin_pos + match.end(1))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module handles measurement and reporting of complexity in methods.
+    module MethodComplexity
+      include ConfigurableMax
+      extend NodePattern::Macros
+
+      def on_def(node)
+        check_complexity(node, node.method_name)
+      end
+      alias on_defs on_def
+
+      def on_block(node)
+        define_method?(node) do |name|
+          check_complexity(node, name)
+        end
+      end
+
+      private
+
+      def_node_matcher :define_method?, <<~PATTERN
+        (block
+         (send nil? :define_method ({sym str} $_))
+         args
+         _)
+      PATTERN
+
+      def check_complexity(node, method_name)
+        # Accepts empty methods always.
+        return unless node.body
+
+        max = cop_config['Max']
+        complexity = complexity(node.body)
+
+        return unless complexity > max
+
+        msg = format(self.class::MSG,
+                     method: method_name,
+                     complexity: complexity,
+                     max: max)
+
+        add_offense(node, message: msg) do
+          self.max = complexity.ceil
+        end
+      end
+
+      def complexity(body)
+        body.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|
+          score + complexity_score_for(n)
+        end
+      end
+    end
+  end
+end