rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects gem dependency order
+    class OrderedGemCorrector
+      extend OrderedGemNode
+
+      class << self
+        attr_reader :processed_source, :comments_as_separators
+
+        def correct(processed_source, node,
+                    previous_declaration, comments_as_separators)
+          @processed_source = processed_source
+          @comments_as_separators = comments_as_separators
+
+          current_range = declaration_with_comment(node)
+          previous_range = declaration_with_comment(previous_declaration)
+
+          lambda do |corrector|
+            swap_range(corrector, current_range, previous_range)
+          end
+        end
+
+        private
+
+        def declaration_with_comment(node)
+          buffer = processed_source.buffer
+          begin_pos = get_source_range(node, comments_as_separators).begin_pos
+          end_line = buffer.line_for_position(node.loc.expression.end_pos)
+          end_pos = buffer.line_range(end_line).end_pos
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
+
+        def swap_range(corrector, range1, range2)
+          src1 = range1.source
+          src2 = range2.source
+          corrector.replace(range1, src2)
+          corrector.replace(range2, src1)
+        end
+      end
+    end
+  end
+end

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 && 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/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,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects whitespace
+    class SpaceCorrector
+      extend SurroundingSpace
+
+      class << self
+        attr_reader :processed_source
+
+        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
+          unless left_token.space_after?
+            corrector.insert_after(left_token.pos, ' ')
+          end
+          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.source_range, to_string_literal(str))
+            else
+              corrector.replace(node.source_range, str.inspect)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects unused arguments.
+    class UnusedArgCorrector
+      extend Util
+
+      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?
+            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
+          else
+            ->(corrector) { corrector.insert_before(node.loc.name, '_') }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/force.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop

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

@@ -0,0 +1,102 @@
+# 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
+        MSG = '`%<assignment>s` method calls already given on line '\
+              '%<line_of_first_occurrence>d of the gemspec.'.freeze
+
+        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 unless processed_source.ast
+
+          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,106 @@
+# 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`.'
+              .freeze
+
+        def investigate(processed_source)
+          return if processed_source.ast.nil?
+          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)
+            )
+            unless get_dependency_name(previous) == get_dependency_name(current)
+              next
+            end
+
+            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} ...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Checks that `required_ruby_version` of gemspec and `TargetRubyVersion`
+      # of .rubocop.yml are equal.
+      # Thereby, RuboCop to perform static analysis working on the version
+      # required by gemspec.
+      #
+      # @example
+      #   # When `TargetRubyVersion` of .rubocop.yml is `2.3`.
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = '>= 2.2.0'
+      #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = '>= 2.4.0'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = '>= 2.3.0'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = '>= 2.3'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = ['>= 2.3.0', '< 2.5.0']
+      #   end
+      class RequiredRubyVersion < Cop
+        MSG = '`required_ruby_version` (%<required_ruby_version>s, ' \
+              'declared in %<gemspec_filename>s) and `TargetRubyVersion` ' \
+              '(%<target_ruby_version>s, declared in .rubocop.yml) ' \
+              'should be equal.'.freeze
+
+        def_node_search :required_ruby_version, <<-PATTERN
+          (send _ :required_ruby_version= ${(str _) (array (str _))})
+        PATTERN
+
+        def investigate(processed_source)
+          required_ruby_version(processed_source.ast) do |version|
+            ruby_version = extract_ruby_version(version)
+
+            return if ruby_version == target_ruby_version.to_s
+
+            add_offense(
+              processed_source.ast,
+              location: version.loc.expression,
+              message: message(ruby_version, target_ruby_version)
+            )
+          end
+        end
+
+        private
+
+        def extract_ruby_version(required_ruby_version)
+          if required_ruby_version.array_type?
+            required_ruby_version = required_ruby_version.children.detect do |v|
+              v.str_content =~ /[>=]/
+            end
+          end
+
+          required_ruby_version.str_content.match(/(\d\.\d)/)[1]
+        end
+
+        def message(required_ruby_version, target_ruby_version)
+          file_path = processed_source.buffer.name
+
+          format(
+            MSG,
+            required_ruby_version: required_ruby_version,
+            gemspec_filename: File.basename(file_path),
+            target_ruby_version: target_ruby_version
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/generator/require_file_injector.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class Generator
+      # A class that injects a require directive into the root RuboCop file.
+      # It looks for other directives that require files in the same (cop)
+      # namespace and injects the provided one in alpha
+      class RequireFileInjector
+        REQUIRE_PATH = /require_relative ['"](.+)['"]/
+
+        def initialize(source_path:, root_file_path:, output: $stdout)
+          @source_path = Pathname(source_path)
+          @root_file_path = Pathname(root_file_path)
+          @require_entries = File.readlines(root_file_path)
+          @output = output
+        end
+
+        def inject
+          return if require_exists? || !target_line
+
+          File.write(root_file_path, updated_directives)
+          require = injectable_require_directive.chomp
+          output.puts "[modify] #{root_file_path} - `#{require}` was injected."
+        end
+
+        private
+
+        attr_reader :require_entries, :root_file_path, :source_path, :output
+
+        def require_exists?
+          require_entries.any? do |entry|
+            entry == injectable_require_directive
+          end
+        end
+
+        def updated_directives
+          require_entries.insert(target_line,
+                                 injectable_require_directive).join
+        end
+
+        def target_line
+          @target_line ||= begin
+            in_the_same_department = false
+            inject_parts = require_path_fragments(injectable_require_directive)
+
+            require_entries.find.with_index do |entry, index|
+              current_entry_parts = require_path_fragments(entry)
+
+              if inject_parts[0..-2] == current_entry_parts[0..-2]
+                in_the_same_department = true
+
+                break index if inject_parts.last < current_entry_parts.last
+              elsif in_the_same_department
+                break index
+              end
+            end
+          end
+        end
+
+        def require_path_fragments(require_directove)
+          path = require_directove.match(REQUIRE_PATH)
+
+          path ? path.captures.first.split('/') : []
+        end
+
+        def injectable_require_directive
+          "require_relative '#{require_path}'\n"
+        end
+
+        def require_path
+          path = source_path.relative_path_from(root_file_path.dirname)
+          path.to_s.sub('.rb', '')
+        end
+      end
+    end
+  end
+end