rbhint 0.8.5.rc1

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common code for empty parameter cops.
+    module EmptyParameter
+      extend NodePattern::Macros
+
+      private
+
+      def_node_matcher :empty_arguments?, <<~PATTERN
+        (block _ $(args) _)
+      PATTERN
+
+      def check(node)
+        empty_arguments?(node) do |args|
+          return if args.empty_and_without_delimiters?
+
+          add_offense(args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Functions for checking the alignment of the `end` keyword.
+    module EndKeywordAlignment
+      include ConfigurableEnforcedStyle
+      include RangeHelp
+
+      MSG = '`end` at %<end_line>d, %<end_col>d is not aligned with ' \
+            '`%<source>s` at %<align_line>d, %<align_col>d.'
+
+      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 if accept_end_kw_alignment?(end_loc)
+
+        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 ||
+            column_offset_between(range, end_loc).zero?
+        end
+      end
+
+      def add_offense_for_misalignment(node, align_with)
+        end_loc = node.loc.end
+        msg = format(MSG, end_line: end_loc.line,
+                          end_col: end_loc.column,
+                          source: align_with.source,
+                          align_line: align_with.line,
+                          align_col: align_with.column)
+        add_offense(node, location: end_loc, message: msg)
+      end
+
+      def accept_end_kw_alignment?(end_loc)
+        end_loc.nil? || # Discard modifier forms of if/while/until.
+          processed_source.lines[end_loc.line - 1] !~ /\A[ \t]*end/
+      end
+
+      def style_parameter_name
+        'EnforcedStyleAlignWith'
+      end
+
+      def variable_alignment?(whole_expression, rhs, end_alignment_style)
+        return if end_alignment_style == :keyword
+
+        !line_break_before_keyword?(whole_expression, rhs)
+      end
+
+      def line_break_before_keyword?(whole_expression, rhs)
+        rhs.first_line > whole_expression.line
+      end
+    end
+  end
+end

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,62 @@
+# 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 frozen_string_literal_specified?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal_specified?
+        end
+      end
+
+      def leading_comment_lines
+        first_non_comment_token = processed_source.tokens.find do |token|
+          !token.comment?
+        end
+
+        if first_non_comment_token
+          # `line` is 1-indexed so we need to subtract 1 to get the array index
+          processed_source.lines[0...first_non_comment_token.line - 1]
+        else
+          processed_source.lines
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking hash alignment.
+    module HashAlignmentStyles
+      # 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/hash_transform_method.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Style/HashTransformKeys and
+    # Style/HashTransformValues
+    module HashTransformMethod
+      def on_block(node)
+        on_bad_each_with_object(node) do |*match|
+          handle_possible_offense(node, match, 'each_with_object')
+        end
+      end
+
+      def on_send(node)
+        on_bad_hash_brackets_map(node) do |*match|
+          handle_possible_offense(node, match, 'Hash[_.map {...}]')
+        end
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map {...}.to_h')
+        end
+      end
+
+      def on_csend(node)
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map {...}.to_h')
+        end
+      end
+
+      def autocorrect(node)
+        lambda do |corrector|
+          correction = prepare_correction(node)
+          execute_correction(corrector, node, correction)
+        end
+      end
+
+      private
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_each_with_object(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_hash_brackets_map(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_map_to_h(_node)
+        raise NotImplementedError
+      end
+
+      def handle_possible_offense(node, match, match_desc)
+        captures = extract_captures(match)
+
+        # If key didn't actually change either, this is most likely a false
+        # positive (receiver isn't a hash).
+        return if captures.noop_transformation?
+
+        # Can't `transform_keys` if key transformation uses value, or
+        # `transform_values` if value transformation uses key.
+        return if captures.transformation_uses_both_args?
+
+        add_offense(
+          node,
+          message: "Prefer `#{new_method_name}` over `#{match_desc}`."
+        )
+      end
+
+      # @abstract
+      #
+      # @return [Captures]
+      def extract_captures(_match)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      #
+      # @return [String]
+      def new_method_name
+        raise NotImplementedError
+      end
+
+      def prepare_correction(node)
+        if (match = on_bad_each_with_object(node))
+          Autocorrection.from_each_with_object(node, match)
+        elsif (match = on_bad_hash_brackets_map(node))
+          Autocorrection.from_hash_brackets_map(node, match)
+        elsif (match = on_bad_map_to_h(node))
+          Autocorrection.from_map_to_h(node, match)
+        else
+          raise 'unreachable'
+        end
+      end
+
+      def execute_correction(corrector, node, correction)
+        correction.strip_prefix_and_suffix(node, corrector)
+        correction.set_new_method_name(new_method_name, corrector)
+
+        captures = extract_captures(correction.match)
+        correction.set_new_arg_name(captures.transformed_argname, corrector)
+        correction.set_new_body_expression(
+          captures.transforming_body_expr,
+          corrector
+        )
+      end
+
+      # Internal helper class to hold match data
+      Captures = Struct.new(
+        :transformed_argname,
+        :transforming_body_expr,
+        :unchanged_body_expr
+      ) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+
+        def transformation_uses_both_args?
+          transforming_body_expr.descendants.include?(unchanged_body_expr)
+        end
+      end
+
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do # rubocop:disable Metrics/BlockLength
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def self.from_map_to_h(node, match)
+          strip_trailing_chars = 0
+
+          unless node.parent&.block_type?
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.loc.expression
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object`
+            # case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(
+            block_node.arguments.loc.expression,
+            "|#{transformed_argname}|"
+          )
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          corrector.replace(
+            block_node.body,
+            transforming_body_expr.loc.expression.source
+          )
+        end
+      end
+    end
+  end
+end