rubocop 0.87.1

data/lib/rubocop/cop/correctors/parentheses_corrector.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects parentheses
+    class ParenthesesCorrector
+      class << self
+        def correct(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+
+            if ternary_condition?(node) && next_char_is_question_mark?(node)
+              corrector.insert_after(node.loc.end, ' ')
+            end
+          end
+        end
+
+        private
+
+        def ternary_condition?(node)
+          node.parent&.if_type? && node.parent&.ternary?
+        end
+
+        def next_char_is_question_mark?(node)
+          node.loc.last_column == node.parent.loc.question.column
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects percent literals
+    class PercentLiteralCorrector
+      include Util
+
+      attr_reader :config, :preferred_delimiters
+
+      def initialize(config, preferred_delimiters)
+        @config = config
+        @preferred_delimiters = preferred_delimiters
+      end
+
+      def correct(node, char)
+        escape = escape_words?(node)
+        char = char.upcase if escape
+        delimiters = delimiters_for("%#{char}")
+        contents = new_contents(node, escape, delimiters)
+        wrap_contents(node, contents, char, delimiters)
+      end
+
+      private
+
+      def wrap_contents(node, contents, char, delimiters)
+        lambda do |corrector|
+          corrector.replace(
+            node,
+            "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}"
+          )
+        end
+      end
+
+      def escape_words?(node)
+        node.children.any? { |w| needs_escaping?(w.children[0]) }
+      end
+
+      def delimiters_for(type)
+        PreferredDelimiters
+          .new(type, config, preferred_delimiters)
+          .delimiters
+      end
+
+      def new_contents(node, escape, delimiters)
+        if node.multiline?
+          autocorrect_multiline_words(node, escape, delimiters)
+        else
+          autocorrect_words(node, escape, delimiters)
+        end
+      end
+
+      def autocorrect_multiline_words(node, escape, delimiters)
+        contents = process_multiline_words(node, escape, delimiters)
+        contents << end_content(node.source)
+        contents.join('')
+      end
+
+      def autocorrect_words(node, escape, delimiters)
+        node.children.map do |word_node|
+          fix_escaped_content(word_node, escape, delimiters)
+        end.join(' ')
+      end
+
+      def process_multiline_words(node, escape, delimiters)
+        base_line_num = node.first_line
+        prev_line_num = base_line_num
+        node.children.map.with_index do |word_node, index|
+          line_breaks = line_breaks(word_node,
+                                    node.source,
+                                    prev_line_num,
+                                    base_line_num,
+                                    index)
+          prev_line_num = word_node.first_line
+          content = fix_escaped_content(word_node, escape, delimiters)
+          line_breaks + content
+        end
+      end
+
+      def line_breaks(node, source, previous_line_num, base_line_num, node_indx)
+        source_in_lines = source.split("\n")
+        if first_line?(node, previous_line_num)
+          node_indx.zero? && node.first_line == base_line_num ? '' : ' '
+        else
+          process_lines(node, previous_line_num, base_line_num, source_in_lines)
+        end
+      end
+
+      def first_line?(node, previous_line_num)
+        node.first_line == previous_line_num
+      end
+
+      def process_lines(node, previous_line_num, base_line_num, source_in_lines)
+        begin_line_num = previous_line_num - base_line_num + 1
+        end_line_num = node.first_line - base_line_num + 1
+        lines = source_in_lines[begin_line_num...end_line_num]
+        "\n#{(lines.join("\n").split(node.source).first || '')}"
+      end
+
+      def fix_escaped_content(word_node, escape, delimiters)
+        content = +word_node.children.first.to_s
+        content = escape_string(content) if escape
+        substitute_escaped_delimiters(content, delimiters)
+        content
+      end
+
+      def substitute_escaped_delimiters(content, delimiters)
+        delimiters.each { |delim| content.gsub!(delim, "\\#{delim}") }
+      end
+
+      def end_content(source)
+        result = /\A(\s*)\]/.match(source.split("\n").last)
+        ("\n" + result[1]) if result
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/punctuation_corrector.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects punctuation
+    class PunctuationCorrector
+      class << self
+        def remove_space(space_before)
+          ->(corrector) { corrector.remove(space_before) }
+        end
+
+        def add_space(token)
+          ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
+        end
+
+        def swap_comma(range)
+          return unless range
+
+          lambda do |corrector|
+            case range.source
+            when ',' then corrector.remove(range)
+            else          corrector.insert_after(range, ',')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/space_corrector.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects whitespace
+    class SpaceCorrector
+      extend SurroundingSpace
+
+      class << self
+        attr_reader :processed_source
+
+        def empty_corrections(processed_source, corrector, empty_config,
+                              left_token, right_token)
+          @processed_source = processed_source
+          range = range_between(left_token.end_pos, right_token.begin_pos)
+          if offending_empty_space?(empty_config, left_token, right_token)
+            corrector.remove(range)
+            corrector.insert_after(left_token.pos, ' ')
+          elsif offending_empty_no_space?(empty_config, left_token, right_token)
+            corrector.remove(range)
+          end
+        end
+
+        def remove_space(processed_source, corrector, left_token, right_token)
+          @processed_source = processed_source
+          if left_token.space_after?
+            range = side_space_range(range: left_token.pos, side: :right)
+            corrector.remove(range)
+          end
+          return unless right_token.space_before?
+
+          range = side_space_range(range: right_token.pos, side: :left)
+          corrector.remove(range)
+        end
+
+        def add_space(processed_source, corrector, left_token, right_token)
+          @processed_source = processed_source
+          corrector.insert_after(left_token.pos, ' ') unless left_token.space_after?
+          return if right_token.space_before?
+
+          corrector.insert_before(right_token.pos, ' ')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/string_literal_corrector.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects string literals
+    class StringLiteralCorrector
+      extend Util
+
+      class << self
+        def correct(node, style)
+          return if node.dstr_type?
+
+          lambda do |corrector|
+            str = node.str_content
+            if style == :single_quotes
+              corrector.replace(node, to_string_literal(str))
+            else
+              corrector.replace(node, str.inspect)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/unused_arg_corrector.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects unused arguments.
+    class UnusedArgCorrector
+      extend RangeHelp
+
+      class << self
+        attr_reader :processed_source
+
+        def correct(processed_source, node)
+          return if %i[kwarg kwoptarg].include?(node.type)
+
+          @processed_source = processed_source
+
+          if node.blockarg_type?
+            correct_for_blockarg_type(node)
+          else
+            lambda do |corrector|
+              variable_name = if node.optarg_type?
+                                node.node_parts[0]
+                              else
+                                # Extract only a var name without splat (`*`)
+                                node.source.gsub(/\A\*+/, '')
+                              end
+              corrector.replace(node.loc.name, "_#{variable_name}")
+            end
+          end
+        end
+
+        def correct_for_blockarg_type(node)
+          lambda do |corrector|
+            range = range_with_surrounding_space(range: node.source_range,
+                                                 side: :left)
+            range = range_with_surrounding_comma(range, :left)
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/force.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # A scaffold for concrete forces.
+    class Force
+      attr_reader :cops
+
+      def self.all
+        @all ||= []
+      end
+
+      def self.inherited(subclass)
+        all << subclass
+      end
+
+      def self.force_name
+        name.split('::').last
+      end
+
+      def initialize(cops)
+        @cops = cops
+      end
+
+      def name
+        self.class.force_name
+      end
+
+      def run_hook(method_name, *args)
+        cops.each do |cop|
+          next unless cop.respond_to?(method_name)
+
+          cop.send(method_name, *args)
+        end
+      end
+
+      def investigate(_processed_source)
+        # Do custom processing and invoke #run_hook at arbitrary timing.
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gemspec/duplicated_assignment.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # An attribute assignment method calls should be listed only once
+      # in a gemspec.
+      #
+      # Assigning to an attribute with the same name using `spec.foo =` will be
+      # an unintended usage. On the other hand, duplication of methods such
+      # as `spec.requirements`, `spec.add_runtime_dependency`, and others are
+      # permitted because it is the intended use of appending values.
+      #
+      # @example
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'rubocop'
+      #     spec.name = 'rubocop2'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'rubocop'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.requirements << 'libmagick, v6.0'
+      #     spec.requirements << 'A good graphics card'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_runtime_dependency('parallel', '~> 1.10')
+      #     spec.add_runtime_dependency('parser', '>= 2.3.3.1', '< 3.0')
+      #   end
+      class DuplicatedAssignment < Cop
+        include RangeHelp
+
+        MSG = '`%<assignment>s` method calls already given on line '\
+              '%<line_of_first_occurrence>d of the gemspec.'
+
+        def_node_search :gem_specification, <<~PATTERN
+          (block
+            (send
+              (const
+                (const {cbase nil?} :Gem) :Specification) :new)
+            (args
+              (arg $_)) ...)
+        PATTERN
+
+        def_node_search :assignment_method_declarations, <<~PATTERN
+          (send
+            (lvar #match_block_variable_name?) #assignment_method? ...)
+        PATTERN
+
+        def investigate(processed_source)
+          return if processed_source.blank?
+
+          duplicated_assignment_method_nodes.each do |nodes|
+            nodes[1..-1].each do |node|
+              register_offense(
+                node,
+                node.method_name,
+                nodes.first.first_line
+              )
+            end
+          end
+        end
+
+        private
+
+        def match_block_variable_name?(receiver_name)
+          gem_specification(processed_source.ast) do |block_variable_name|
+            return block_variable_name == receiver_name
+          end
+        end
+
+        def assignment_method?(method_name)
+          method_name.to_s.end_with?('=')
+        end
+
+        def duplicated_assignment_method_nodes
+          assignment_method_declarations(processed_source.ast)
+            .group_by(&:method_name)
+            .values
+            .select { |nodes| nodes.size > 1 }
+        end
+
+        def register_offense(node, assignment, line_of_first_occurrence)
+          line_range = node.loc.column...node.loc.last_column
+          offense_location =
+            source_range(processed_source.buffer, node.first_line, line_range)
+          message = format(
+            MSG,
+            assignment: assignment,
+            line_of_first_occurrence: line_of_first_occurrence
+          )
+          add_offense(node, location: offense_location, message: message)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Dependencies in the gemspec should be alphabetically sorted.
+      #
+      # @example
+      #   # bad
+      #   spec.add_dependency 'rubocop'
+      #   spec.add_dependency 'rspec'
+      #
+      #   # good
+      #   spec.add_dependency 'rspec'
+      #   spec.add_dependency 'rubocop'
+      #
+      #   # good
+      #   spec.add_dependency 'rubocop'
+      #
+      #   spec.add_dependency 'rspec'
+      #
+      #   # bad
+      #   spec.add_development_dependency 'rubocop'
+      #   spec.add_development_dependency 'rspec'
+      #
+      #   # good
+      #   spec.add_development_dependency 'rspec'
+      #   spec.add_development_dependency 'rubocop'
+      #
+      #   # good
+      #   spec.add_development_dependency 'rubocop'
+      #
+      #   spec.add_development_dependency 'rspec'
+      #
+      #   # bad
+      #   spec.add_runtime_dependency 'rubocop'
+      #   spec.add_runtime_dependency 'rspec'
+      #
+      #   # good
+      #   spec.add_runtime_dependency 'rspec'
+      #   spec.add_runtime_dependency 'rubocop'
+      #
+      #   # good
+      #   spec.add_runtime_dependency 'rubocop'
+      #
+      #   spec.add_runtime_dependency 'rspec'
+      #
+      #   # good only if TreatCommentsAsGroupSeparators is true
+      #   # For code quality
+      #   spec.add_dependency 'rubocop'
+      #   # For tests
+      #   spec.add_dependency 'rspec'
+      class OrderedDependencies < Cop
+        include ConfigurableEnforcedStyle
+        include OrderedGemNode
+
+        MSG = 'Dependencies should be sorted in an alphabetical order within ' \
+              'their section of the gemspec. '\
+              'Dependency `%<previous>s` should appear before `%<current>s`.'
+
+        def investigate(processed_source)
+          return if processed_source.blank?
+
+          dependency_declarations(processed_source.ast)
+            .each_cons(2) do |previous, current|
+            next unless consecutive_lines(previous, current)
+            next unless case_insensitive_out_of_order?(
+              gem_name(current),
+              gem_name(previous)
+            )
+            next unless get_dependency_name(previous) == get_dependency_name(current)
+
+            register_offense(previous, current)
+          end
+        end
+
+        def autocorrect(node)
+          OrderedGemCorrector.correct(
+            processed_source,
+            node,
+            previous_declaration(node),
+            treat_comments_as_separators
+          )
+        end
+
+        private
+
+        def previous_declaration(node)
+          declarations = dependency_declarations(processed_source.ast)
+          node_index = declarations.find_index(node)
+          declarations.to_a[node_index - 1]
+        end
+
+        def get_dependency_name(node)
+          node.method_name
+        end
+
+        def_node_search :dependency_declarations, <<~PATTERN
+          (send (lvar _) {:add_dependency :add_runtime_dependency :add_development_dependency} (str _) ...)
+        PATTERN
+      end
+    end
+  end
+end