rbhint 0.8.5.rc1

data/lib/rubocop/cop/style/empty_method.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the formatting of empty method definitions.
+      # By default it enforces empty method definitions to go on a single
+      # line (compact style), but it can be configured to enforce the `end`
+      # to go on its own line (expanded style).
+      #
+      # NOTE: A method definition is not considered empty if it contains
+      #       comments.
+      #
+      # @example EnforcedStyle: compact (default)
+      #   # bad
+      #   def foo(bar)
+      #   end
+      #
+      #   def self.foo(bar)
+      #   end
+      #
+      #   # good
+      #   def foo(bar); end
+      #
+      #   def foo(bar)
+      #     # baz
+      #   end
+      #
+      #   def self.foo(bar); end
+      #
+      # @example EnforcedStyle: expanded
+      #   # bad
+      #   def foo(bar); end
+      #
+      #   def self.foo(bar); end
+      #
+      #   # good
+      #   def foo(bar)
+      #   end
+      #
+      #   def self.foo(bar)
+      #   end
+      class EmptyMethod < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_COMPACT = 'Put empty method definitions on a single line.'
+        MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
+                       'next line.'
+
+        def on_def(node)
+          return if node.body || comment_lines?(node)
+          return if correct_style?(node)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, corrected(node))
+          end
+        end
+
+        private
+
+        def message(_node)
+          compact_style? ? MSG_COMPACT : MSG_EXPANDED
+        end
+
+        def correct_style?(node)
+          compact_style? && compact?(node) ||
+            expanded_style? && expanded?(node)
+        end
+
+        def corrected(node)
+          if node.arguments?
+            arguments   = node.arguments.source
+            extra_space = ' ' unless parentheses?(node.arguments)
+          end
+          scope = node.receiver ? "#{node.receiver.source}." : ''
+
+          signature = [scope, node.method_name, extra_space, arguments].join
+
+          ["def #{signature}", 'end'].join(joint(node))
+        end
+
+        def joint(node)
+          indent = ' ' * node.loc.column
+
+          compact_style? ? '; ' : "\n#{indent}"
+        end
+
+        def compact?(node)
+          node.single_line?
+        end
+
+        def expanded?(node)
+          node.multiline?
+        end
+
+        def compact_style?
+          style == :compact
+        end
+
+        def expanded_style?
+          style == :expanded
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/encoding.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks ensures source files have no utf-8 encoding comments.
+      # @example
+      #   # bad
+      #   # encoding: UTF-8
+      #   # coding: UTF-8
+      #   # -*- coding: UTF-8 -*-
+      class Encoding < Cop
+        include RangeHelp
+
+        MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
+        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/.freeze
+        SHEBANG = '#!'
+
+        def investigate(processed_source)
+          return if processed_source.buffer.source.empty?
+
+          line_number = encoding_line_number(processed_source)
+          return unless (@message = offense(processed_source, line_number))
+
+          range = processed_source.buffer.line_range(line_number + 1)
+          add_offense(range, location: range, message: @message)
+        end
+
+        def autocorrect(range)
+          lambda do |corrector|
+            corrector.remove(range_with_surrounding_space(range: range,
+                                                          side: :right))
+          end
+        end
+
+        private
+
+        def offense(processed_source, line_number)
+          line = processed_source[line_number]
+
+          MSG_UNNECESSARY if encoding_omitable?(line)
+        end
+
+        def encoding_omitable?(line)
+          line =~ ENCODING_PATTERN
+        end
+
+        def encoding_line_number(processed_source)
+          line_number = 0
+          line_number += 1 if processed_source[line_number].start_with?(SHEBANG)
+          line_number
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/end_block.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for END blocks.
+      #
+      # @example
+      #   # bad
+      #   END { puts 'Goodbye!' }
+      #
+      #   # good
+      #   at_exit { puts 'Goodbye!' }
+      #
+      class EndBlock < Cop
+        MSG = 'Avoid the use of `END` blocks. ' \
+              'Use `Kernel#at_exit` instead.'
+
+        def on_postexe(node)
+          add_offense(node, location: :keyword)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.keyword, 'at_exit')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/eval_with_location.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks `eval` method usage. `eval` can receive source location
+      # metadata, that are filename and line number. The metadata is used by
+      # backtraces. This cop recommends to pass the metadata to `eval` method.
+      #
+      # @example
+      #   # bad
+      #   eval <<-RUBY
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # bad
+      #   C.class_eval <<-RUBY
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # good
+      #   eval <<-RUBY, binding, __FILE__, __LINE__ + 1
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # good
+      #   C.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      #     def do_something
+      #     end
+      #   RUBY
+      class EvalWithLocation < Cop
+        MSG = 'Pass `__FILE__` and `__LINE__` to `eval` method, ' \
+              'as they are used by backtraces.'
+        MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
+                             'as they are used by backtraces.'
+
+        def_node_matcher :eval_without_location?, <<~PATTERN
+          {
+            (send nil? :eval ${str dstr})
+            (send nil? :eval ${str dstr} _)
+            (send nil? :eval ${str dstr} _ #special_file_keyword?)
+            (send nil? :eval ${str dstr} _ #special_file_keyword? _)
+
+            (send _ {:class_eval :module_eval :instance_eval}
+              ${str dstr})
+            (send _ {:class_eval :module_eval :instance_eval}
+              ${str dstr} #special_file_keyword?)
+            (send _ {:class_eval :module_eval :instance_eval}
+              ${str dstr} #special_file_keyword? _)
+          }
+        PATTERN
+
+        def_node_matcher :line_with_offset?, <<~PATTERN
+          {
+            (send #special_line_keyword? %1 (int %2))
+            (send (int %2) %1 #special_line_keyword?)
+          }
+        PATTERN
+
+        def on_send(node)
+          eval_without_location?(node) do |code|
+            if with_lineno?(node)
+              on_with_lineno(node, code)
+            else
+              add_offense(node)
+            end
+          end
+        end
+
+        private
+
+        def special_file_keyword?(node)
+          node.str_type? &&
+            node.source == '__FILE__'
+        end
+
+        def special_line_keyword?(node)
+          node.int_type? &&
+            node.source == '__LINE__'
+        end
+
+        # FIXME: It's a Style/ConditionalAssignment's false positive.
+        # rubocop:disable Style/ConditionalAssignment
+        def with_lineno?(node)
+          if node.method?(:eval)
+            node.arguments.size == 4
+          else
+            node.arguments.size == 3
+          end
+        end
+        # rubocop:enable Style/ConditionalAssignment
+
+        def message_incorrect_line(actual, sign, line_diff)
+          expected =
+            if line_diff.zero?
+              '__LINE__'
+            else
+              "__LINE__ #{sign} #{line_diff}"
+            end
+          format(MSG_INCORRECT_LINE, actual: actual.source, expected: expected)
+        end
+
+        def on_with_lineno(node, code)
+          line_node = node.arguments.last
+          lineno_range = line_node.loc.expression
+          line_diff = string_first_line(code) - lineno_range.first_line
+          if line_diff.zero?
+            add_offense_for_same_line(node, line_node)
+          else
+            add_offense_for_different_line(node, line_node, line_diff)
+          end
+        end
+
+        def string_first_line(str_node)
+          if str_node.heredoc?
+            str_node.loc.heredoc_body.first_line
+          else
+            str_node.loc.expression.first_line
+          end
+        end
+
+        def add_offense_for_same_line(node, line_node)
+          return if special_line_keyword?(line_node)
+
+          add_offense(
+            node,
+            location: line_node.loc.expression,
+            message: message_incorrect_line(line_node, nil, 0)
+          )
+        end
+
+        def add_offense_for_different_line(node, line_node, line_diff)
+          sign = line_diff.positive? ? :+ : :-
+          return if line_with_offset?(line_node, sign, line_diff.abs)
+
+          add_offense(
+            node,
+            location: line_node.loc.expression,
+            message: message_incorrect_line(line_node, sign, line_diff.abs)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/even_odd.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where `Integer#even?` or `Integer#odd?`
+      # can be used.
+      #
+      # @example
+      #
+      #   # bad
+      #   if x % 2 == 0
+      #   end
+      #
+      #   # good
+      #   if x.even?
+      #   end
+      class EvenOdd < Cop
+        MSG = 'Replace with `Integer#%<method>s?`.'
+
+        def_node_matcher :even_odd_candidate?, <<~PATTERN
+          (send
+            {(send $_ :% (int 2))
+             (begin (send $_ :% (int 2)))}
+            ${:== :!=}
+            (int ${0 1}))
+        PATTERN
+
+        def on_send(node)
+          even_odd_candidate?(node) do |_base_number, method, arg|
+            replacement_method = replacement_method(arg, method)
+            add_offense(node, message: format(MSG, method: replacement_method))
+          end
+        end
+
+        def autocorrect(node)
+          even_odd_candidate?(node) do |base_number, method, arg|
+            replacement_method = replacement_method(arg, method)
+
+            correction = "#{base_number.source}.#{replacement_method}?"
+            ->(corrector) { corrector.replace(node, correction) }
+          end
+        end
+
+        private
+
+        def replacement_method(arg, method)
+          case arg
+          when 0
+            method == :== ? :even : :odd
+          when 1
+            method == :== ? :odd : :even
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/expand_path_arguments.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for use of the `File.expand_path` arguments.
+      # Likewise, it also checks for the `Pathname.new` argument.
+      #
+      # Contrastive bad case and good case are alternately shown in
+      # the following examples.
+      #
+      # @example
+      #   # bad
+      #   File.expand_path('..', __FILE__)
+      #
+      #   # good
+      #   File.expand_path(__dir__)
+      #
+      #   # bad
+      #   File.expand_path('../..', __FILE__)
+      #
+      #   # good
+      #   File.expand_path('..', __dir__)
+      #
+      #   # bad
+      #   File.expand_path('.', __FILE__)
+      #
+      #   # good
+      #   File.expand_path(__FILE__)
+      #
+      #   # bad
+      #   Pathname(__FILE__).parent.expand_path
+      #
+      #   # good
+      #   Pathname(__dir__).expand_path
+      #
+      #   # bad
+      #   Pathname.new(__FILE__).parent.expand_path
+      #
+      #   # good
+      #   Pathname.new(__dir__).expand_path
+      #
+      class ExpandPathArguments < Cop
+        include RangeHelp
+
+        MSG = 'Use `expand_path(%<new_path>s%<new_default_dir>s)` instead of ' \
+              '`expand_path(%<current_path>s, __FILE__)`.'
+        PATHNAME_MSG = 'Use `Pathname(__dir__).expand_path` instead of ' \
+                       '`Pathname(__FILE__).parent.expand_path`.'
+        PATHNAME_NEW_MSG = 'Use `Pathname.new(__dir__).expand_path` ' \
+                           'instead of ' \
+                           '`Pathname.new(__FILE__).parent.expand_path`.'
+
+        def_node_matcher :file_expand_path, <<~PATTERN
+          (send
+            (const nil? :File) :expand_path
+            $_
+            $_)
+        PATTERN
+
+        def_node_matcher :pathname_parent_expand_path, <<~PATTERN
+          (send
+            (send
+              (send nil? :Pathname
+                $_) :parent) :expand_path)
+        PATTERN
+
+        def_node_matcher :pathname_new_parent_expand_path, <<~PATTERN
+          (send
+            (send
+              (send
+                (const nil? :Pathname) :new
+                $_) :parent) :expand_path)
+        PATTERN
+
+        def on_send(node)
+          if (captured_values = file_expand_path(node))
+            current_path, default_dir = captured_values
+
+            inspect_offense_for_expand_path(node, current_path, default_dir)
+          elsif (default_dir = pathname_parent_expand_path(node))
+            return unless unrecommended_argument?(default_dir)
+
+            add_offense(node, message: PATHNAME_MSG)
+          elsif (default_dir = pathname_new_parent_expand_path(node))
+            return unless unrecommended_argument?(default_dir)
+
+            add_offense(node, message: PATHNAME_NEW_MSG)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if (captured_values = file_expand_path(node))
+              current_path, default_dir = captured_values
+
+              autocorrect_expand_path(corrector, current_path, default_dir)
+            elsif (default_dir = pathname_parent_expand_path(node)) ||
+                  (default_dir = pathname_new_parent_expand_path(node))
+              corrector.replace(default_dir, '__dir__')
+              remove_parent_method(corrector, default_dir)
+            end
+          end
+        end
+
+        private
+
+        def unrecommended_argument?(default_dir)
+          default_dir.source == '__FILE__'
+        end
+
+        def inspect_offense_for_expand_path(node, current_path, default_dir)
+          return unless unrecommended_argument?(default_dir) &&
+                        current_path.str_type?
+
+          current_path = strip_surrounded_quotes!(current_path.source)
+
+          parent_path = parent_path(current_path)
+          new_path = parent_path == '' ? '' : "'#{parent_path}', "
+
+          new_default_dir = depth(current_path).zero? ? '__FILE__' : '__dir__'
+
+          message = format(
+            MSG,
+            new_path: new_path,
+            new_default_dir: new_default_dir,
+            current_path: "'#{current_path}'"
+          )
+
+          add_offense(node, location: :selector, message: message)
+        end
+
+        def autocorrect_expand_path(corrector, current_path, default_dir)
+          stripped_current_path = strip_surrounded_quotes!(current_path.source)
+
+          case depth(stripped_current_path)
+          when 0
+            range = arguments_range(current_path)
+
+            corrector.replace(range, '__FILE__')
+          when 1
+            range = arguments_range(current_path)
+
+            corrector.replace(range, '__dir__')
+          else
+            new_path = "'#{parent_path(stripped_current_path)}'"
+
+            corrector.replace(current_path, new_path)
+            corrector.replace(default_dir, '__dir__')
+          end
+        end
+
+        def strip_surrounded_quotes!(path_string)
+          path_string.slice!(path_string.length - 1)
+          path_string.slice!(0)
+
+          path_string
+        end
+
+        def depth(current_path)
+          paths = current_path.split(File::SEPARATOR)
+
+          paths.count { |path| path != '.' }
+        end
+
+        def parent_path(current_path)
+          paths = current_path.split(File::SEPARATOR)
+
+          paths.delete('.')
+          paths.each_with_index do |path, index|
+            if path == '..'
+              paths.delete_at(index)
+              break
+            end
+          end
+
+          paths.join(File::SEPARATOR)
+        end
+
+        def remove_parent_method(corrector, default_dir)
+          node = default_dir.parent.parent.parent.children.first
+
+          corrector.remove(node.loc.dot)
+          corrector.remove(node.loc.selector)
+        end
+
+        def arguments_range(node)
+          range_between(node.parent.first_argument.source_range.begin_pos,
+                        node.parent.last_argument.source_range.end_pos)
+        end
+      end
+    end
+  end
+end