rubbycop 0.49.0

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Functions for checking the alignment of the `end` keyword.
+    module EndKeywordAlignment
+      include ConfigurableEnforcedStyle
+
+      MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'.freeze
+
+      private
+
+      def check_end_kw_in_node(node)
+        check_end_kw_alignment(node, style => node.loc.keyword)
+      end
+
+      def check_end_kw_alignment(node, align_ranges)
+        return if ignored_node?(node)
+
+        end_loc = node.loc.end
+        return unless end_loc # Discard modifier forms of if/while/until.
+
+        matching = matching_ranges(end_loc, align_ranges)
+
+        if matching.key?(style)
+          correct_style_detected
+        else
+          add_offense_for_misalignment(node, align_ranges[style])
+          style_detected(matching.keys)
+        end
+      end
+
+      def matching_ranges(end_loc, align_ranges)
+        align_ranges.select do |_, range|
+          range.line == end_loc.line ||
+            effective_column(range) == end_loc.column
+        end
+      end
+
+      def add_offense_for_misalignment(node, align_with)
+        end_loc = node.loc.end
+        msg = format(MSG, end_loc.line, end_loc.column, align_with.source,
+                     align_with.line, align_with.column)
+        add_offense(node, end_loc, msg)
+      end
+
+      def style_parameter_name
+        'EnforcedStyleAlignWith'
+      end
+
+      def variable_alignment?(whole_expression, rhs, end_alignment_style)
+        end_alignment_style == :variable &&
+          !line_break_before_keyword?(whole_expression, rhs)
+      end
+
+      def line_break_before_keyword?(whole_expression, rhs)
+        rhs.loc.line > whole_expression.line
+      end
+
+      def align(node, align_to)
+        whitespace = whitespace_range(node)
+        return false unless whitespace.source.strip.empty?
+
+        column = alignment_column(align_to)
+        ->(corrector) { corrector.replace(whitespace, ' ' * column) }
+      end
+
+      def whitespace_range(node)
+        begin_pos = node.loc.end.begin_pos
+
+        range_between(begin_pos - node.loc.end.column, begin_pos)
+      end
+
+      def alignment_column(align_to)
+        if !align_to
+          0
+        elsif align_to.respond_to?(:loc)
+          align_to.source_range.column
+        else
+          align_to.column
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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], :expression, self.class::MSG)
+        end
+      end
+
+      def on_send(node)
+        class_new_definition(node) do
+          add_offense(node.children.last, :expression, self.class::MSG)
+        end
+      end
+
+      def autocorrect(node)
+        lambda do |corrector|
+          corrector.replace(node.source_range, self.class::SUPERCLASS)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking for a line break before the first
+    # element in a multi-line collection.
+    module FirstElementLineBreak
+      def autocorrect(node)
+        ->(corrector) { corrector.insert_before(node.source_range, "\n") }
+      end
+
+      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.loc.line
+        min = children.min_by { |n| n.loc.first_line }
+        return if line != min.loc.first_line
+
+        max = children.max_by { |n| n.loc.last_line }
+        return if line == max.loc.last_line
+
+        add_offense(min, :expression, self.class::MSG)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for dealing with frozen string literals.
+    module FrozenStringLiteral
+      module_function
+
+      FROZEN_STRING_LITERAL = '# frozen_string_literal:'.freeze
+      FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'.freeze
+      FROZEN_STRING_LITERAL_TYPES = %i[str dstr].freeze
+
+      def frozen_string_literal_comment_exists?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal_specified?
+        end
+      end
+
+      def frozen_string_literals_enabled?
+        ruby_version = processed_source.ruby_version
+        return false unless ruby_version
+        return true if ruby_version >= 3.0
+        return false unless ruby_version >= 2.3
+
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal?
+        end
+      end
+
+      private
+
+      def leading_comment_lines
+        processed_source[0..2].compact
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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(*)
+          {}
+        end
+
+        def deltas(first_pair, current_pair)
+          if Util.begins_its_line?(current_pair.source_range)
+            { key: first_pair.key_delta(current_pair) }
+          else
+            {}
+          end
+        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
+
+        # The table style is the only one where the first key-value pair can
+        # be considered to have bad alignment.
+        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(*)
+          {}
+        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/rubbycop/cop/mixin/ignored_pattern.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # This module encapsulates the ability to ignore certain lines when
+    # parsing.
+    module IgnoredPattern
+      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/rubbycop/cop/mixin/integer_node.rb

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for obtaining source ranges from regexp matches
+    module MatchRange
+      # 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/rubbycop/cop/mixin/method_complexity.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # This module handles measurement and reporting of complexity in methods.
+    module MethodComplexity
+      include OnMethodDef
+      include ConfigurableMax
+
+      private
+
+      def on_method_def(node, method_name, _args, _body)
+        max = cop_config['Max']
+        complexity = complexity(node)
+        return unless complexity > max
+
+        add_offense(node, :keyword,
+                    format(self.class::MSG, method_name, complexity, max)) do
+          self.max = complexity.ceil
+        end
+      end
+
+      def complexity(node)
+        node.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|
+          score + complexity_score_for(n)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common code for cops that deal with preferred methods.
+    module MethodPreference
+      private
+
+      def preferred_method(method)
+        preferred_methods[method.to_sym]
+      end
+
+      def preferred_methods
+        @preferred_methods ||=
+          begin
+            # Make sure default configuration 'foo' => 'bar' is removed from
+            # the total configuration if there is a 'bar' => 'foo' override.
+            default = default_cop_config['PreferredMethods']
+            merged = cop_config['PreferredMethods']
+            overrides = merged.values - default.values
+            merged.reject { |key, _| overrides.include?(key) }.symbolize_keys
+          end
+      end
+
+      def default_cop_config
+        ConfigLoader.default_configuration[cop_name]
+      end
+    end
+  end
+end