rubocop 0.35.1 → 0.36.0

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

@@ -0,0 +1,120 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for `private` or `protected` access modifiers which are
+      # applied to a singleton method. These access modifiers do not make
+      # singleton methods private/protected. `private_class_method` can be
+      # used for that.
+      #
+      # @example
+      #   @bad
+      #   class C
+      #     private
+      #
+      #     def self.method
+      #       puts 'hi'
+      #     end
+      #   end
+      #
+      #   @good
+      #   class C
+      #     def self.method
+      #       puts 'hi'
+      #     end
+      #
+      #     private_class_method :method
+      #   end
+      #
+      #   class C
+      #     class << self
+      #       private
+      #
+      #       def method
+      #         puts 'hi'
+      #       end
+      #     end
+      #   end
+      class IneffectiveAccessModifier < Cop
+        MSG = '`%s` (on line %d) does not make singleton methods %s. ' \
+              'Use %s instead.'.freeze
+        ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a ' \
+                              '`class << self` block'.freeze
+        ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
+                                'block'.freeze
+
+        def_node_matcher :access_modifier, <<-PATTERN
+          (send nil ${:public :protected :private})
+        PATTERN
+
+        def_node_matcher :private_class_method, <<-PATTERN
+          (send nil :private_class_method $...)
+        PATTERN
+
+        def on_class(node)
+          check_node(node.children[2]) # class body
+        end
+
+        def on_module(node)
+          check_node(node.children[1]) # module body
+        end
+
+        private
+
+        def clear
+          @useless = {}
+          @last_access_modifier = nil
+        end
+
+        def check_node(node)
+          if node && node.begin_type?
+            clear
+            check_scope(node)
+
+            @useless.each do |_name, (defs_node, visibility, modifier)|
+              add_offense(defs_node, :keyword,
+                          format_message(visibility, modifier))
+            end
+          end
+        end
+
+        def format_message(visibility, modifier)
+          alternative = if visibility == :private
+                          ALTERNATIVE_PRIVATE
+                        else
+                          ALTERNATIVE_PROTECTED
+                        end
+          format(MSG, visibility, modifier.location.expression.line, visibility,
+                 alternative)
+        end
+
+        def check_scope(node, cur_vis = :public)
+          node.children.each do |child|
+            if (new_vis = access_modifier(child))
+              @last_access_modifier = child
+              cur_vis = new_vis
+            elsif child.defs_type?
+              if cur_vis != :public
+                _, method_name, = *child
+                @useless[method_name] = [child, cur_vis, @last_access_modifier]
+              end
+            elsif (methods = private_class_method(child))
+              # don't warn about defs nodes which are followed by a call to
+              # `private_class_method :name`
+              # obviously the programmer knows what they are doing
+              methods.select(&:sym_type?).each do |sym|
+                @useless.delete(sym.children[0])
+              end
+            elsif child.kwbegin_type?
+              cur_vis = check_scope(child, cur_vis)
+            end
+          end
+
+          cur_vis
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -27,7 +28,8 @@ module RuboCop
         end
 
         def alternative_message(diagnostic)
-          diagnostic.message
+          diagnostic
+            .message
             .capitalize
             .gsub('character syntax', 'character literal')
         end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -18,7 +19,7 @@ module RuboCop
       #   end
       #
       class LiteralInCondition < Cop
-        MSG = 'Literal `%s` appeared in a condition.'
+        MSG = 'Literal `%s` appeared in a condition.'.freeze
 
         def on_if(node)
           check_for_literal(node)
@@ -53,7 +54,7 @@ module RuboCop
         end
 
         def message(node)
-          format(MSG, node.loc.expression.source)
+          format(MSG, node.source)
         end
 
         private
@@ -62,7 +63,7 @@ module RuboCop
           cond, = *node
 
           # if the cond node is literal we obviously have a problem
-          if literal?(cond)
+          if cond.literal?
             add_offense(cond, :expression)
           else
             # alternatively we have to consider a logical node with a
@@ -79,15 +80,11 @@ module RuboCop
           method_name == :!
         end
 
-        def literal?(node)
-          LITERALS.include?(node.type)
-        end
-
         def basic_literal?(node)
           if node && node.type == :array
             primitive_array?(node)
           else
-            BASIC_LITERALS.include?(node.type)
+            node.basic_literal?
           end
         end
 
@@ -114,7 +111,7 @@ module RuboCop
         end
 
         def handle_node(node)
-          if literal?(node)
+          if node.literal?
             add_offense(node, :expression)
           elsif [:send, :and, :or, :begin].include?(node.type)
             check_node(node)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -9,26 +10,22 @@ module RuboCop
       #
       #   "result is #{10}"
       class LiteralInInterpolation < Cop
-        LITERALS = [:str, :dstr, :int, :float, :array,
-                    :hash, :regexp, :nil, :true, :false]
-
-        MSG = 'Literal interpolation detected.'
+        MSG = 'Literal interpolation detected.'.freeze
 
         def on_dstr(node)
           node.children.select { |n| n.type == :begin }.each do |begin_node|
             final_node = begin_node.children.last
             next unless final_node
             next if special_keyword?(final_node)
-            next unless LITERALS.include?(final_node.type)
+            next unless final_node.literal?
 
             add_offense(final_node, :expression)
           end
         end
 
         def autocorrect(node)
-          expr = node.parent.loc.expression
           value = autocorrected_value(node)
-          ->(corrector) { corrector.replace(expr, value) }
+          ->(corrector) { corrector.replace(node.parent.source_range, value) }
         end
 
         private
@@ -36,11 +33,11 @@ module RuboCop
         def special_keyword?(node)
           # handle strings like __FILE__
           (node.type == :str && !node.loc.respond_to?(:begin)) ||
-            node.loc.expression.is?('__LINE__')
+            node.source_range.is?('__LINE__')
         end
 
         def autocorrected_value(node)
-          node.str_type? ? node.children.last : node.loc.expression.source
+          node.str_type? ? node.children.last : node.source
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
       # This cop checks for uses of *begin...end while/until something*.
       class Loop < Cop
         MSG = 'Use `Kernel#loop` with `break` rather than ' \
-              '`begin/end/until`(or `while`).'
+              '`begin/end/until`(or `while`).'.freeze
 
         def on_while_post(node)
           register_offense(node)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -8,7 +9,7 @@ module RuboCop
       # @example
       #   # `bar` definition actually produces methods in the same scope
       #   # as the outer `foo` method. Furthermore, the `bar` method
-      #   # will be redefined every time the `foo` is invoked
+      #   # will be redefined every time `foo` is invoked.
       #   def foo
       #     def bar
       #     end
@@ -16,15 +17,30 @@ module RuboCop
       #
       class NestedMethodDefinition < Cop
         include OnMethodDef
+        extend RuboCop::NodePattern::Macros
 
         MSG = 'Method definitions must not be nested. ' \
-              'Use `lambda` instead.'
+              'Use `lambda` instead.'.freeze
+
+        def_node_matcher :eval_call?, <<-PATTERN
+          (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+        PATTERN
 
         def on_method_def(node, _method_name, _args, _body)
-          node.each_descendant(:def) do |nested_def_node|
+          find_nested_defs(node) do |nested_def_node|
             add_offense(nested_def_node, :expression)
           end
         end
+
+        def find_nested_defs(node, &block)
+          node.each_child_node do |child|
+            if child.def_type? || child.defs_type?
+              yield child
+            elsif !eval_call?(child)
+              find_nested_defs(child, &block)
+            end
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,38 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Don't omit the accumulator when calling `next` in a `reduce` block.
+      #
+      # @example
+      #   # bad
+      #   result = (1..4).reduce(0) do |acc, i|
+      #     next if i.odd?
+      #     acc + i
+      #   end
+      #
+      #   # good
+      #   result = (1..4).reduce(0) do |acc, i|
+      #     next acc if i.odd?
+      #     acc + i
+      #   end
+      class NextWithoutAccumulator < Cop
+        MSG = 'Use `next` with an accumulator argument in a `reduce`.'.freeze
+
+        def_node_matcher :on_body_of_reduce, <<-PATTERN
+          (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
+        PATTERN
+
+        def on_block(node)
+          on_body_of_reduce(node) do |body|
+            void_next = body.each_node(:next).find { |n| n.children.empty? }
+
+            add_offense(void_next, :expression) if void_next
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -12,7 +13,7 @@ module RuboCop
       #
       #   class ItemApi
       #     rescue_from ValidationError do |e| # non-iteration block with arg
-      #       return message: 'validation error' unless e.errors # allowd
+      #       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
@@ -34,7 +35,8 @@ module RuboCop
       #
       class NonLocalExitFromIterator < Cop
         MSG = 'Non-local exit from iterator, without return value. ' \
-          '`next`, `break`, `Array#find`, `Array#any?`, etc. is preferred.'
+              '`next`, `break`, `Array#find`, `Array#any?`, etc. ' \
+              'is preferred.'.freeze
 
         def on_return(return_node)
           return if return_value?(return_node)
@@ -42,7 +44,7 @@ module RuboCop
             send_node, args_node, _body_node = *block_node
 
             # `return` does not exit to outside of lambda block, this is safe.
-            break if lambda?(send_node)
+            break if block_node.lambda?
             # if a proc is passed to `Module#define_method`, `return` will not
             # cause a non-local exit error
             break if define_method?(send_node)
@@ -64,11 +66,6 @@ module RuboCop
           !receiver_node.nil?
         end
 
-        def lambda?(send_node)
-          receiver_node, selector_node = *send_node
-          receiver_node.nil? && selector_node == :lambda
-        end
-
         def define_method?(send_node)
           _receiver, selector = *send_node
           selector == :define_method

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -10,16 +11,17 @@ module RuboCop
       #
       #   puts (x + y)
       class ParenthesesAsGroupedExpression < Cop
-        MSG = '`(...)` interpreted as grouped expression.'
+        MSG = '`(...)` interpreted as grouped expression.'.freeze
 
         def on_send(node)
-          _receiver, method_name, args = *node
+          _receiver, method_name, *args = *node
           return if operator?(method_name) || node.asgn_method_call?
-          return unless args && args.loc.expression.source.start_with?('(')
+          return unless args.first && args.first.source.start_with?('(')
+          return if args.size > 1
 
           space_length = spaces_before_left_parenthesis(node)
           return unless space_length > 0
-          expr = args.loc.expression
+          expr = args.first.source_range
           space_range =
             Parser::Source::Range.new(expr.source_buffer,
                                       expr.begin_pos - space_length,
@@ -33,11 +35,11 @@ module RuboCop
         def spaces_before_left_parenthesis(node)
           receiver, method_name, _args = *node
           receiver_length = if receiver
-                              receiver.loc.expression.source.length
+                              receiver.source.length
                             else
                               0
                             end
-          without_receiver = node.loc.expression.source[receiver_length..-1]
+          without_receiver = node.source[receiver_length..-1]
 
           # Escape question mark if any.
           method_regexp = Regexp.escape(method_name)

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

@@ -0,0 +1,36 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for `rand(1)` calls.
+      # Such calls always return `0`.
+      #
+      # @example
+      #
+      #   @bad
+      #   rand 1
+      #   Kernel.rand(-1)
+      #   rand 1.0
+      #   rand(-1.0)
+      #
+      #   @good
+      #   0
+      class RandOne < Cop
+        MSG = '`%s` always returns `0`. ' \
+              'Perhaps you meant `rand(2)` or `rand`?'.freeze
+
+        def_node_matcher :rand_one?, <<-PATTERN
+          (send {(const nil :Kernel) nil} :rand {(int {-1 1}) (float {-1.0 1.0})})
+        PATTERN
+
+        def on_send(node)
+          if rand_one?(node)
+            add_offense(node, :expression, format(MSG, node.source))
+          end
+        end
+      end
+    end
+  end
+end