rbhint 0.8.5.rc1

data/lib/rubocop/cop/lint/useless_comparison.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for comparison of something with itself.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   x.top >= x.top
+      class UselessComparison < Cop
+        MSG = 'Comparison of something with itself detected.'
+        OPS = %w[== === != < > <= >= <=>].freeze
+
+        def_node_matcher :useless_comparison?,
+                         "(send $_match {:#{OPS.join(' :')}} $_match)"
+
+        def on_send(node)
+          return unless useless_comparison?(node)
+
+          add_offense(node, location: :selector)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/useless_else_without_rescue.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for useless `else` in `begin..end` without `rescue`.
+      #
+      # NOTE: This syntax is no longer valid on Ruby 2.6 or higher and
+      # this cop is going to be removed at some point the future.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   else
+      #     do_something_else # This will never be run.
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   rescue
+      #     handle_errors
+      #   else
+      #     do_something_else
+      #   end
+      class UselessElseWithoutRescue < Cop
+        include ParserDiagnostic
+
+        MSG = '`else` without `rescue` is useless.'
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :useless_else
+        end
+
+        def find_offense_node_by(diagnostic)
+          # TODO: When implementing auto-correction, this method should return
+          # an offense node passed as first argument of `add_offense` method.
+        end
+
+        def alternative_message(_diagnostic)
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for setter call to local variable as the final
+      # expression of a function definition.
+      #
+      # NOTE: There are edge cases in which the local variable references a
+      # value that is also accessible outside the local scope. This is not
+      # detected by the cop, and it can yield a false positive.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def something
+      #     x = Something.new
+      #     x.attr = 5
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def something
+      #     x = Something.new
+      #     x.attr = 5
+      #     x
+      #   end
+      class UselessSetterCall < Cop
+        MSG = 'Useless setter call to local variable `%<variable>s`.'
+        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
+
+        def on_def(node)
+          return unless node.body
+
+          last_expr = last_expression(node.body)
+          return unless setter_call_to_local_variable?(last_expr)
+
+          tracker = MethodVariableTracker.new(node.body)
+          receiver, = *last_expr
+          variable_name, = *receiver
+          return unless tracker.contain_local_object?(variable_name)
+
+          add_offense(
+            receiver,
+            location: :name,
+            message: format(MSG, variable: receiver.loc.name.source)
+          )
+        end
+        alias on_defs on_def
+
+        private
+
+        def_node_matcher :setter_call_to_local_variable?, <<~PATTERN
+          [(send (lvar _) ...) setter_method?]
+        PATTERN
+
+        def last_expression(body)
+          expression = body.begin_type? ? body.children : body
+
+          expression.is_a?(Array) ? expression.last : expression
+        end
+
+        # This class tracks variable assignments in a method body
+        # and if a variable contains object passed as argument at the end of
+        # the method.
+        class MethodVariableTracker
+          def initialize(body_node)
+            @body_node = body_node
+            @local = nil
+          end
+
+          def contain_local_object?(variable_name)
+            return @local[variable_name] if @local
+
+            @local = {}
+
+            scan(@body_node) { |node| process_assignment_node(node) }
+
+            @local[variable_name]
+          end
+
+          def scan(node, &block)
+            catch(:skip_children) do
+              yield node
+
+              node.each_child_node do |child_node|
+                scan(child_node, &block)
+              end
+            end
+          end
+
+          def process_assignment_node(node)
+            case node.type
+            when :masgn
+              process_multiple_assignment(node)
+            when :or_asgn, :and_asgn
+              process_logical_operator_assignment(node)
+            when :op_asgn
+              process_binary_operator_assignment(node)
+            when *ASSIGNMENT_TYPES
+              _, rhs_node = *node
+              process_assignment(node, rhs_node) if rhs_node
+            end
+          end
+
+          def process_multiple_assignment(masgn_node)
+            mlhs_node, mrhs_node = *masgn_node
+
+            mlhs_node.children.each_with_index do |lhs_node, index|
+              next unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+
+              lhs_variable_name, = *lhs_node
+              rhs_node = mrhs_node.children[index]
+
+              if mrhs_node.array_type? && rhs_node
+                process_assignment(lhs_variable_name, rhs_node)
+              else
+                @local[lhs_variable_name] = true
+              end
+            end
+
+            throw :skip_children
+          end
+
+          def process_logical_operator_assignment(asgn_node)
+            lhs_node, rhs_node = *asgn_node
+            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+
+            process_assignment(lhs_node, rhs_node)
+
+            throw :skip_children
+          end
+
+          def process_binary_operator_assignment(op_asgn_node)
+            lhs_node, = *op_asgn_node
+            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+
+            lhs_variable_name, = *lhs_node
+            @local[lhs_variable_name] = true
+
+            throw :skip_children
+          end
+
+          def process_assignment(asgn_node, rhs_node)
+            lhs_variable_name, = *asgn_node
+
+            @local[lhs_variable_name] = if rhs_node.variable?
+                                          rhs_variable_name, = *rhs_node
+                                          @local[rhs_variable_name]
+                                        else
+                                          constructor?(rhs_node)
+                                        end
+          end
+
+          def constructor?(node)
+            return true if node.literal?
+            return false unless node.send_type?
+
+            node.method?(:new)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/void.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for operators, variables, literals, and nonmutating
+      # methods used in void context.
+      #
+      # @example CheckForMethodsWithNoSideEffects: false (default)
+      #   # bad
+      #   def some_method
+      #     some_num * 10
+      #     do_something
+      #   end
+      #
+      #   def some_method(some_var)
+      #     some_var
+      #     do_something
+      #   end
+      #
+      # @example CheckForMethodsWithNoSideEffects: true
+      #   # bad
+      #   def some_method(some_array)
+      #     some_array.sort
+      #     do_something(some_array)
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #     some_num * 10
+      #   end
+      #
+      #   def some_method(some_var)
+      #     do_something
+      #     some_var
+      #   end
+      #
+      #   def some_method(some_array)
+      #     some_array.sort!
+      #     do_something(some_array)
+      #   end
+      class Void < Cop
+        OP_MSG = 'Operator `%<op>s` used in void context.'
+        VAR_MSG = 'Variable `%<var>s` used in void context.'
+        LIT_MSG = 'Literal `%<lit>s` used in void context.'
+        SELF_MSG = '`self` used in void context.'
+        DEFINED_MSG = '`%<defined>s` used in void context.'
+        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. ' \
+          'Did you mean `#%<method>s!`?'
+
+        BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
+        UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
+        OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
+        VOID_CONTEXT_TYPES = %i[def for block].freeze
+        NONMUTATING_METHODS = %i[capitalize chomp chop collect compact
+                                 delete_prefix delete_suffix downcase
+                                 encode flatten gsub lstrip map merge next
+                                 reject reverse rotate rstrip scrub select
+                                 shuffle slice sort sort_by squeeze strip sub
+                                 succ swapcase tr tr_s transform_values
+                                 unicode_normalize uniq upcase].freeze
+
+        def on_block(node)
+          return unless node.body && !node.body.begin_type?
+          return unless in_void_context?(node.body)
+
+          check_expression(node.body)
+        end
+
+        def on_begin(node)
+          check_begin(node)
+        end
+        alias on_kwbegin on_begin
+
+        private
+
+        def check_begin(node)
+          expressions = *node
+          expressions.pop unless in_void_context?(node)
+          expressions.each do |expr|
+            check_expression(expr)
+          end
+        end
+
+        def check_expression(expr)
+          check_void_op(expr)
+          check_literal(expr)
+          check_var(expr)
+          check_self(expr)
+          check_defined(expr)
+          return unless cop_config['CheckForMethodsWithNoSideEffects']
+
+          check_nonmutating(expr)
+        end
+
+        def check_void_op(node)
+          return unless node.send_type? && OPERATORS.include?(node.method_name)
+
+          add_offense(node,
+                      location: :selector,
+                      message: format(OP_MSG, op: node.method_name))
+        end
+
+        def check_var(node)
+          return unless node.variable? || node.const_type?
+
+          add_offense(node,
+                      location: :name,
+                      message: format(VAR_MSG, var: node.loc.name.source))
+        end
+
+        def check_literal(node)
+          return if !node.literal? || node.xstr_type?
+
+          add_offense(node, message: format(LIT_MSG, lit: node.source))
+        end
+
+        def check_self(node)
+          return unless node.self_type?
+
+          add_offense(node, message: SELF_MSG)
+        end
+
+        def check_defined(node)
+          return unless node.defined_type?
+
+          add_offense(node, message: format(DEFINED_MSG, defined: node.source))
+        end
+
+        def check_nonmutating(node)
+          unless node.send_type? &&
+                 NONMUTATING_METHODS.include?(node.method_name)
+            return
+          end
+
+          add_offense(node, message: format(NONMUTATING_MSG,
+                                            method: node.method_name))
+        end
+
+        def in_void_context?(node)
+          parent = node.parent
+
+          return false unless parent && parent.children.last == node
+
+          VOID_CONTEXT_TYPES.include?(parent.type) && parent.void_context?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/message_annotator.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Message Annotator class annotates a basic offense message
+    # based on params passed into initializer.
+    #
+    # @see #initialize
+    #
+    # @example
+    #   RuboCop::Cop::MessageAnnotator.new(
+    #     config, cop_name, cop_config, @options
+    #   ).annotate('message')
+    #  #=> 'Cop/CopName: message (http://example.org/styleguide)'
+    class MessageAnnotator
+      attr_reader :options, :config, :cop_name, :cop_config
+
+      @style_guide_urls = {}
+
+      class << self
+        attr_reader :style_guide_urls
+      end
+
+      # @param config [RuboCop::Config] Check configs for all cops
+      #   @note Message Annotator specifically checks the
+      #     following config options for_all_cops
+      #     :StyleGuideBaseURL [String] URL for styleguide
+      #     :DisplayStyleGuide [Boolean] Include styleguide and reference URLs
+      #     :ExtraDetails [Boolean] Include cop details
+      #     :DisplayCopNames [Boolean] Include cop name
+      #
+      # @param [String] cop_name for specific cop name
+      # @param [Hash] cop_config configs for specific cop, from config#for_cop
+      # @option cop_config [String] :StyleGuide Extension of base styleguide URL
+      # @option cop_config [String] :Reference Full reference URL
+      # @option cop_config [String] :Details
+      #
+      # @param [Hash, nil] options optional
+      # @option options [Boolean] :display_style_guide
+      #   Include style guide and reference URLs
+      # @option options [Boolean] :extra_details
+      #   Include cop specific details
+      # @option options [Boolean] :debug
+      #   Include debug output
+      # @option options [Boolean] :display_cop_names
+      #   Include cop name
+      def initialize(config, cop_name, cop_config, options)
+        @config = config
+        @cop_name = cop_name
+        @cop_config = cop_config || {}
+        @options = options
+      end
+
+      # Returns the annotated message,
+      # based on params passed into initializer
+      #
+      # @return [String] annotated message
+      def annotate(message)
+        message = "#{cop_name}: #{message}" if display_cop_names?
+        message += " #{details}" if extra_details? && details
+        if display_style_guide?
+          links = urls.join(', ')
+          message = "#{message} (#{links})"
+        end
+        message
+      end
+
+      def urls
+        [style_guide_url, *reference_urls].compact
+      end
+
+      private
+
+      def style_guide_url
+        url = cop_config['StyleGuide']
+        return nil if url.nil? || url.empty?
+
+        self.class.style_guide_urls[url] ||= begin
+          base_url = style_guide_base_url
+          if base_url.nil? || base_url.empty?
+            url
+          else
+            URI.join(base_url, url).to_s
+          end
+        end
+      end
+
+      def style_guide_base_url
+        department_name = cop_name.split('/').first
+
+        config.for_department(department_name)['StyleGuideBaseURL'] ||
+          config.for_all_cops['StyleGuideBaseURL']
+      end
+
+      def display_style_guide?
+        (options[:display_style_guide] ||
+         config.for_all_cops['DisplayStyleGuide']) &&
+          !urls.empty?
+      end
+
+      def reference_urls
+        urls = Array(cop_config['Reference'])
+        urls.nil? || urls.empty? ? nil : urls.reject(&:empty?)
+      end
+
+      def extra_details?
+        options[:extra_details] || config.for_all_cops['ExtraDetails']
+      end
+
+      def debug?
+        options[:debug]
+      end
+
+      def display_cop_names?
+        return true if debug?
+        return false if options[:display_cop_names] == false
+        return true if options[:display_cop_names]
+        return false if options[:format] == 'json'
+
+        config.for_all_cops['DisplayCopNames']
+      end
+
+      def details
+        details = cop_config && cop_config['Details']
+        details.nil? || details.empty? ? nil : details
+      end
+    end
+  end
+end