rbhint 0.8.5.rc1

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # `Dir[...]` and `Dir.glob(...)` do not make any guarantees about
+      # the order in which files are returned. The final order is
+      # determined by the operating system and file system.
+      # This means that using them in cases where the order matters,
+      # such as requiring files, can lead to intermittent failures
+      # that are hard to debug. To ensure this doesn't happen,
+      # always sort the list.
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir["./lib/**/*.rb"].each do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir["./lib/**/*.rb"].sort.each do |file|
+      #     require file
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')).sort.each do |file|
+      #     require file
+      #   end
+      #
+      class NonDeterministicRequireOrder < Cop
+        MSG = 'Sort files before requiring them.'
+
+        def on_block(node)
+          return unless node.body
+          return unless unsorted_dir_loop?(node.send_node)
+
+          loop_variable(node.arguments) do |var_name|
+            return unless var_is_required?(node.body, var_name)
+
+            add_offense(node.send_node)
+          end
+        end
+
+        def autocorrect(node)
+          if unsorted_dir_block?(node)
+            lambda do |corrector|
+              corrector.replace(node, "#{node.source}.sort.each")
+            end
+          else
+            lambda do |corrector|
+              source = node.receiver.source
+              corrector.replace(node, "#{source}.sort.each")
+            end
+          end
+        end
+
+        private
+
+        def unsorted_dir_loop?(node)
+          unsorted_dir_block?(node) || unsorted_dir_each?(node)
+        end
+
+        def_node_matcher :unsorted_dir_block?, <<~PATTERN
+          (send (const nil? :Dir) :glob ...)
+        PATTERN
+
+        def_node_matcher :unsorted_dir_each?, <<~PATTERN
+          (send (send (const nil? :Dir) {:[] :glob} ...) :each)
+        PATTERN
+
+        def_node_matcher :loop_variable, <<~PATTERN
+          (args (arg $_))
+        PATTERN
+
+        def_node_search :var_is_required?, <<~PATTERN
+          (send nil? :require (lvar %1))
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for non-local exits from iterators without a return
+      # value. It registers an offense under these conditions:
+      #
+      # * No value is returned,
+      # * the block is preceded by a method chain,
+      # * the block has arguments,
+      # * the method which receives the block is not `define_method`
+      # or `define_singleton_method`,
+      # * the return is not contained in an inner scope, e.g. a lambda or a
+      # method definition.
+      #
+      # @example
+      #
+      #   class ItemApi
+      #     rescue_from ValidationError do |e| # non-iteration block with arg
+      #       return { message: 'validation error' } unless e.errors # allowed
+      #       error_array = e.errors.map do |error| # block with method chain
+      #         return if error.suppress? # warned
+      #         return "#{error.param}: invalid" unless error.message # allowed
+      #         "#{error.param}: #{error.message}"
+      #       end
+      #       { message: 'validation error', errors: error_array }
+      #     end
+      #
+      #     def update_items
+      #       transaction do # block without arguments
+      #         return unless update_necessary? # allowed
+      #         find_each do |item| # block without method chain
+      #           return if item.stock == 0 # false-negative...
+      #           item.update!(foobar: true)
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      class NonLocalExitFromIterator < Cop
+        MSG = 'Non-local exit from iterator, without return value. ' \
+              '`next`, `break`, `Array#find`, `Array#any?`, etc. ' \
+              'is preferred.'
+
+        def on_return(return_node)
+          return if return_value?(return_node)
+
+          return_node.each_ancestor(:block, :def, :defs) do |node|
+            break if scoped_node?(node)
+
+            # if a proc is passed to `Module#define_method` or
+            # `Object#define_singleton_method`, `return` will not cause a
+            # non-local exit error
+            break if define_method?(node.send_node)
+
+            next unless node.arguments?
+
+            if chained_send?(node.send_node)
+              add_offense(return_node, location: :keyword)
+              break
+            end
+          end
+        end
+
+        private
+
+        def scoped_node?(node)
+          node.def_type? || node.defs_type? || node.lambda?
+        end
+
+        def return_value?(return_node)
+          !return_node.children.empty?
+        end
+
+        def_node_matcher :chained_send?, '(send !nil? ...)'
+        def_node_matcher :define_method?, <<~PATTERN
+          (send _ {:define_method :define_singleton_method} _)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop warns the usage of unsafe number conversions. Unsafe
+      # number conversion can cause unexpected error if auto type conversion
+      # fails. Cop prefer parsing with number class instead.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   '10'.to_i
+      #   '10.2'.to_f
+      #   '10'.to_c
+      #
+      #   # good
+      #
+      #   Integer('10', 10)
+      #   Float('10.2')
+      #   Complex('10')
+      class NumberConversion < Cop
+        CONVERSION_METHOD_CLASS_MAPPING = {
+          to_i: "#{Integer.name}(%<number_object>s, 10)",
+          to_f: "#{Float.name}(%<number_object>s)",
+          to_c: "#{Complex.name}(%<number_object>s)"
+        }.freeze
+        MSG = 'Replace unsafe number conversion with number '\
+              'class parsing, instead of using '\
+              '%<number_object>s.%<to_method>s, use stricter '\
+              '%<corrected_method>s.'
+
+        def_node_matcher :to_method, <<~PATTERN
+          (send $_ ${:to_i :to_f :to_c})
+        PATTERN
+
+        def_node_matcher :datetime?, <<~PATTERN
+          (send (const {nil? (cbase)} {:Time :DateTime}) ...)
+        PATTERN
+
+        def on_send(node)
+          to_method(node) do |receiver, to_method|
+            next if receiver.nil? || date_time_object?(receiver)
+
+            message = format(
+              MSG,
+              number_object: receiver.source,
+              to_method: to_method,
+              corrected_method: correct_method(node, receiver)
+            )
+            add_offense(node, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node,
+                              correct_method(node, node.receiver))
+          end
+        end
+
+        private
+
+        def date_time_object?(node)
+          child = node
+          while child&.send_type?
+            return true if datetime? child
+
+            child = child.children[0]
+          end
+        end
+
+        def correct_method(node, receiver)
+          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
+                 number_object: receiver.source)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # Checks the proper ordering of magic comments and whether
+      # a magic comment is not placed before a shebang.
+      #
+      # @example
+      #   # bad
+      #
+      #   # frozen_string_literal: true
+      #   # encoding: ascii
+      #   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:UTF-8>]
+      #
+      #   # good
+      #
+      #   # encoding: ascii
+      #   # frozen_string_literal: true
+      #   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:US-ASCII>]
+      #
+      #   # good
+      #
+      #   #!/usr/bin/env ruby
+      #   # encoding: ascii
+      #   # frozen_string_literal: true
+      #   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:US-ASCII>]
+      #
+      class OrderedMagicComments < Cop
+        include FrozenStringLiteral
+
+        MSG = 'The encoding magic comment should precede all other ' \
+              'magic comments.'
+
+        def investigate(processed_source)
+          return if processed_source.buffer.source.empty?
+
+          encoding_line, frozen_string_literal_line = magic_comment_lines
+
+          return unless encoding_line && frozen_string_literal_line
+          return if encoding_line < frozen_string_literal_line
+
+          range = processed_source.buffer.line_range(encoding_line + 1)
+
+          add_offense(range, location: range)
+        end
+
+        def autocorrect(_node)
+          encoding_line, frozen_string_literal_line = magic_comment_lines
+
+          range1 = processed_source.buffer.line_range(encoding_line + 1)
+          range2 =
+            processed_source.buffer.line_range(frozen_string_literal_line + 1)
+
+          lambda do |corrector|
+            corrector.replace(range1, range2.source)
+            corrector.replace(range2, range1.source)
+          end
+        end
+
+        private
+
+        def magic_comment_lines
+          lines = [nil, nil]
+
+          magic_comments.each.with_index do |comment, index|
+            if comment.encoding_specified?
+              lines[0] = index
+            elsif comment.frozen_string_literal_specified?
+              lines[1] = index
+            end
+
+            return lines if lines[0] && lines[1]
+          end
+
+          lines
+        end
+
+        def magic_comments
+          leading_comment_lines.map { |line| MagicComment.parse(line) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for space between the name of a called method and a left
+      # parenthesis.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something (foo)
+      #
+      #   # good
+      #   do_something(foo)
+      #   do_something (2 + 3) * 4
+      #   do_something (foo * bar).baz
+      class ParenthesesAsGroupedExpression < Cop
+        include RangeHelp
+
+        MSG = '`(...)` interpreted as grouped expression.'
+
+        def on_send(node)
+          return if valid_context?(node)
+
+          space_length = spaces_before_left_parenthesis(node)
+          return unless space_length.positive?
+
+          range = space_range(node.first_argument.source_range, space_length)
+
+          add_offense(node, location: range)
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          space_length = spaces_before_left_parenthesis(node)
+          range = space_range(node.first_argument.source_range, space_length)
+
+          lambda do |corrector|
+            corrector.remove(range)
+          end
+        end
+
+        private
+
+        def valid_context?(node)
+          unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
+            return true
+          end
+
+          node.operator_method? || node.setter_method? || grouped_parentheses?(node)
+        end
+
+        def first_argument_starts_with_left_parenthesis?(node)
+          node.first_argument.source.start_with?('(')
+        end
+
+        def grouped_parentheses?(node)
+          first_argument = node.first_argument
+
+          first_argument.send_type? && first_argument.receiver&.begin_type?
+        end
+
+        def spaces_before_left_parenthesis(node)
+          receiver = node.receiver
+          receiver_length = if receiver
+                              receiver.source.length
+                            else
+                              0
+                            end
+          without_receiver = node.source[receiver_length..-1]
+
+          # Escape question mark if any.
+          method_regexp = Regexp.escape(node.method_name)
+
+          match = without_receiver.match(/^\s*&?\.?\s*#{method_regexp}(\s+)\(/)
+          match ? match.captures[0].length : 0
+        end
+
+        def space_range(expr, space_length)
+          range_between(expr.begin_pos - space_length, expr.begin_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for quotes and commas in %w, e.g. `%w('foo', "bar")`
+      #
+      # It is more likely that the additional characters are unintended (for
+      # example, mistranslating an array of literals to percent string notation)
+      # rather than meant to be part of the resulting strings.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   %w('foo', "bar")
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   %w(foo bar)
+      class PercentStringArray < Cop
+        include PercentLiteral
+
+        QUOTES_AND_COMMAS = [/,$/, /^'.*'$/, /^".*"$/].freeze
+        LEADING_QUOTE = /^['"]/.freeze
+        TRAILING_QUOTE = /['"]?,?$/.freeze
+
+        MSG = "Within `%w`/`%W`, quotes and ',' are unnecessary and may be " \
+          'unwanted in the resulting strings.'
+
+        def on_array(node)
+          process(node, '%w', '%W')
+        end
+
+        def on_percent_literal(node)
+          return unless contains_quotes_or_commas?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            node.each_value do |value|
+              range = value.loc.expression
+
+              match = range.source.match(TRAILING_QUOTE)
+              corrector.remove_trailing(range, match[0].length) if match
+
+              corrector.remove_leading(range, 1) if LEADING_QUOTE.match?(range.source)
+            end
+          end
+        end
+
+        private
+
+        def contains_quotes_or_commas?(node)
+          node.values.any? do |value|
+            literal = value.children.first.to_s.scrub
+
+            # To avoid likely false positives (e.g. a single ' or ")
+            next if literal.gsub(/[^[[:alnum:]]]/, '').empty?
+
+            QUOTES_AND_COMMAS.any? { |pat| literal =~ pat }
+          end
+        end
+      end
+    end
+  end
+end