rubbycop 0.49.0

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for handling parentheses.
+    module Parentheses
+      def parens_required?(node)
+        range  = node.source_range
+        source = range.source_buffer.source
+        source[range.begin_pos - 1] =~ /[a-z]/ ||
+          source[range.end_pos] =~ /[a-z]/
+      end
+
+      def autocorrect(node)
+        lambda do |corrector|
+          corrector.remove(node.loc.begin)
+          corrector.remove(node.loc.end)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for cops which processes Parser's diagnostics.
+    # This mixin requires its user class to define `#relevant_diagnostic?`.
+    #
+    #     def relevant_diagnostic?(diagnostic)
+    #       diagnostic.reason == :my_interested_diagnostic_type
+    #     end
+    #
+    # If you want to use an alternative offense message rather than the one in
+    # Parser's diagnostic, define `#alternative_message`.
+    #
+    #     def alternative_message(diagnostic)
+    #       'My custom message'
+    #     end
+    module ParserDiagnostic
+      def investigate(processed_source)
+        processed_source.diagnostics.each do |d|
+          next unless relevant_diagnostic?(d)
+
+          message = if respond_to?(:alternative_message, true)
+                      alternative_message(d)
+                    else
+                      d.message.capitalize
+                    end
+
+          add_offense(nil, d.location, message, d.level)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for handling percent literals.
+    module PercentLiteral
+      PERCENT_LITERAL_TYPES = %w[% %i %I %q %Q %r %s %w %W %x].freeze
+
+      private
+
+      def percent_literal?(node)
+        return unless (begin_source = begin_source(node))
+        begin_source.start_with?('%')
+      end
+
+      def process(node, *types)
+        return unless percent_literal?(node) && types.include?(type(node))
+        on_percent_literal(node)
+      end
+
+      def begin_source(node)
+        node.loc.begin.source if node.loc.respond_to?(:begin) && node.loc.begin
+      end
+
+      def type(node)
+        node.loc.begin.source[0..-2]
+      end
+
+      # A range containing only the contents of the percent literal (e.g. in
+      # %i{1 2 3} this will be the range covering '1 2 3' only)
+      def contents_range(node)
+        range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
+      end
+
+      # ['a', 'b', 'c'] => %w(a b c)
+      def correct_percent(node, char)
+        words = node.children
+        escape = words.any? { |w| needs_escaping?(w.children[0]) }
+        char = char.upcase if escape
+        delimiters = preferred_delimiters_for("%#{char}")
+        contents = autocorrect_words(words, escape, node.loc.line, delimiters)
+
+        lambda do |corrector|
+          corrector.replace(
+            node.source_range,
+            "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}"
+          )
+        end
+      end
+
+      def autocorrect_words(word_nodes, escape, base_line_number, delimiters)
+        previous_node_line_number = base_line_number
+        word_nodes.map do |node|
+          number_of_line_breaks = node.loc.line - previous_node_line_number
+          line_breaks = "\n" * number_of_line_breaks
+          previous_node_line_number = node.loc.line
+          content = node.children.first.to_s
+          content = escape ? escape_string(content) : content
+          delimiters.each do |delimiter|
+            content.gsub!(delimiter, "\\#{delimiter}")
+          end
+          line_breaks + content
+        end.join(' ')
+      end
+
+      def ensure_valid_preferred_delimiters
+        invalid = preferred_delimiters_config.keys -
+                  (PERCENT_LITERAL_TYPES + %w[default])
+        return if invalid.empty?
+
+        raise ArgumentError,
+              "Invalid preferred delimiter config key: #{invalid.join(', ')}"
+      end
+
+      def preferred_delimiters
+        @preferred_delimiters ||=
+          begin
+            ensure_valid_preferred_delimiters
+
+            if preferred_delimiters_config.key?('default')
+              Hash[PERCENT_LITERAL_TYPES.map do |type|
+                [type, preferred_delimiters_config[type] ||
+                  preferred_delimiters_config['default']]
+              end]
+            else
+              preferred_delimiters_config
+            end
+          end
+      end
+
+      def preferred_delimiters_config
+        @config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']
+      end
+
+      def preferred_delimiters_for(type)
+        preferred_delimiters[type].split(//)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking whether an AST node/token is aligned
+    # with something on a preceding or following line
+    module PrecedingFollowingAlignment
+      def allow_for_alignment?
+        cop_config['AllowForAlignment']
+      end
+
+      def aligned_with_something?(range)
+        aligned_with_adjacent_line?(range, method(:aligned_token?))
+      end
+
+      def aligned_with_operator?(range)
+        aligned_with_adjacent_line?(range, method(:aligned_operator?))
+      end
+
+      def aligned_with_adjacent_line?(range, predicate)
+        # minus 2 because node.loc.line is zero-based
+        pre  = (range.line - 2).downto(0)
+        post = range.line.upto(processed_source.lines.size - 1)
+
+        aligned_with_any_line_range?([pre, post], range, &predicate)
+      end
+
+      def aligned_with_any_line_range?(line_ranges, range, &predicate)
+        return true if aligned_with_any_line?(line_ranges, range, &predicate)
+
+        # If no aligned token was found, search for an aligned token on the
+        # nearest line with the same indentation as the checked line.
+        base_indentation = processed_source.lines[range.line - 1] =~ /\S/
+
+        aligned_with_any_line?(line_ranges, range, base_indentation, &predicate)
+      end
+
+      def aligned_with_any_line?(line_ranges, range, indent = nil, &predicate)
+        line_ranges.any? do |line_nos|
+          aligned_with_line?(line_nos, range, indent, &predicate)
+        end
+      end
+
+      def aligned_with_line?(line_nos, range, indent = nil)
+        line_nos.each do |lineno|
+          next if comment_lines.include?(lineno + 1)
+          line = processed_source.lines[lineno]
+          index = line =~ /\S/
+          next unless index
+          next if indent && indent != index
+          return yield(range, line)
+        end
+        false
+      end
+
+      def comment_lines
+        @comment_lines ||= processed_source.comments.map(&:loc).select do |r|
+          begins_its_line?(r.expression)
+        end.map(&:line)
+      end
+
+      def aligned_token?(range, line)
+        aligned_words?(range, line) ||
+          aligned_char?(range, line) ||
+          aligned_assignment?(range, line)
+      end
+
+      def aligned_operator?(range, line)
+        (aligned_identical?(range, line) || aligned_assignment?(range, line))
+      end
+
+      def aligned_words?(range, line)
+        line[range.column - 1, 2] =~ /\s\S/
+      end
+
+      def aligned_char?(range, line)
+        line[range.column] == range.source[0]
+      end
+
+      def aligned_assignment?(range, line)
+        range.source[-1] == '=' && line[range.last_column - 1] == '='
+      end
+
+      def aligned_identical?(range, line)
+        range.source == line[range.column, range.size]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking `rescue` nodes.
+    module RescueNode
+      def investigate(processed_source)
+        @modifier_locations = processed_source
+                              .tokens
+                              .select { |t| t.type == :kRESCUE_MOD }
+                              .map(&:pos)
+      end
+
+      def rescue_modifier?(node)
+        node &&
+          node.resbody_type? &&
+          @modifier_locations.include?(node.loc.keyword)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for safe assignment. By safe assignment we mean
+    # putting parentheses around an assignment to indicate "I know I'm using an
+    # assignment as a condition. It's not a mistake."
+    module SafeAssignment
+      extend NodePattern::Macros
+
+      def_node_matcher :empty_condition?, '(begin)'
+      def_node_matcher :safe_assignment?,
+                       '(begin {equals_asgn? asgn_method_call?})'
+
+      def safe_assignment_allowed?
+        cop_config['AllowSafeAssignment']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for Rails safe mode.
+    module SafeMode
+      private
+
+      def rails_safe_mode?
+        safe_mode? || rails?
+      end
+
+      def safe_mode?
+        cop_config['SafeMode']
+      end
+
+      def rails?
+        config['Rails'] && config['Rails'].fetch('Enabled')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for cops checking for missing space after
+    # punctuation.
+    module SpaceAfterPunctuation
+      MSG = 'Space missing after %s.'.freeze
+
+      def investigate(processed_source)
+        each_missing_space(processed_source.tokens) do |token|
+          add_offense(token, token.pos, format(MSG, kind(token)))
+        end
+      end
+
+      def each_missing_space(tokens)
+        tokens.each_cons(2) do |t1, t2|
+          next unless kind(t1)
+          next unless space_missing?(t1, t2)
+          next unless space_required_before?(t2)
+
+          yield t1
+        end
+      end
+
+      def space_missing?(t1, t2)
+        t1.pos.line == t2.pos.line && t2.pos.column == t1.pos.column + offset
+      end
+
+      def space_required_before?(token)
+        !(allowed_type?(token) ||
+          (token.type == :tRCURLY && space_forbidden_before_rcurly?))
+      end
+
+      def allowed_type?(token)
+        %i[tRPAREN tRBRACK tPIPE].include?(token.type)
+      end
+
+      def space_forbidden_before_rcurly?
+        style = space_style_before_rcurly
+        style == 'no_space'
+      end
+
+      # The normal offset, i.e., the distance from the punctuation
+      # token where a space should be, is 1.
+      def offset
+        1
+      end
+
+      def autocorrect(token)
+        ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for cops checking for space before
+    # punctuation.
+    module SpaceBeforePunctuation
+      MSG = 'Space found before %s.'.freeze
+
+      def investigate(processed_source)
+        each_missing_space(processed_source.tokens) do |token, pos_before|
+          add_offense(pos_before, pos_before, format(MSG, kind(token)))
+        end
+      end
+
+      def each_missing_space(tokens)
+        tokens.each_cons(2) do |t1, t2|
+          next unless kind(t2)
+          next unless space_missing?(t1, t2)
+          next if space_required_after?(t1)
+
+          pos_before_punctuation = range_between(t1.pos.end_pos,
+                                                 t2.pos.begin_pos)
+
+          yield t2, pos_before_punctuation
+        end
+      end
+
+      def space_missing?(t1, t2)
+        t1.pos.line == t2.pos.line && t2.pos.begin_pos > t1.pos.end_pos
+      end
+
+      def space_required_after?(token)
+        token.type == :tLCURLY && space_required_after_lcurly?
+      end
+
+      def space_required_after_lcurly?
+        cfg = config.for_cop('Layout/SpaceInsideBlockBraces')
+        style = cfg['EnforcedStyle'] || 'space'
+        style == 'space'
+      end
+
+      def autocorrect(pos_before_punctuation)
+        ->(corrector) { corrector.remove(pos_before_punctuation) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking for spaces inside various
+    # kinds of brackets.
+    module SpaceInside
+      include SurroundingSpace
+      MSG = 'Space inside %s detected.'.freeze
+
+      def investigate(processed_source)
+        @processed_source = processed_source
+        each_extraneous_space(processed_source.tokens) do |kind, range|
+          add_offense(range, range, format(MSG, kind))
+        end
+      end
+
+      def autocorrect(range)
+        ->(corrector) { corrector.remove(range) }
+      end
+
+      private
+
+      def each_extraneous_space(tokens)
+        brackets = Brackets.new(*specifics)
+        tokens.each_cons(2) do |t1, t2|
+          next unless matching_brackets?(brackets, t1, t2)
+
+          # If the second token is a comment, that means that a line break
+          # follows, and that the rules for space inside don't apply.
+          next if t2.type == :tCOMMENT
+          next unless t2.pos.line == t1.pos.line && space_between?(t1, t2)
+
+          yield brackets.kind, range_between_tokens(t1, t2)
+        end
+      end
+
+      def matching_brackets?(brackets, t1, t2)
+        brackets.left_side?(t1) || brackets.right_side?(t2)
+      end
+
+      def range_between_tokens(t1, t2)
+        range_between(t1.pos.end_pos, t2.pos.begin_pos)
+      end
+
+      # Wraps info about the brackets. Makes it easy to check whether a token
+      # is one of the brackets.
+      #
+      # @example Parentheses `()`
+      #   Brackets.new(:tLPAREN, :tRPAREN, 'parentheses')
+      #
+      # @example Square brackets `[]`
+      #   Brackets.new([:tLBRACK, :tLBRACK2], :tRBRACK, 'square brackets')
+      #
+      class Brackets
+        attr_reader :kind
+
+        def initialize(left, right, kind)
+          @left_side_types = [left].flatten
+          @right_side_type = right
+          @kind = kind
+        end
+
+        def left_side?(token)
+          # Left side bracket has to be able to match multiple types
+          # (e.g. :tLBRACK and :tLBRACK2)
+          @left_side_types.include?(token.type)
+        end
+
+        def right_side?(token)
+          @right_side_type == token.type
+        end
+      end
+    end
+  end
+end