rubocop 0.25.0 → 0.26.0

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

@@ -46,7 +46,7 @@ module RuboCop
         end
 
         def next_line_empty?(next_line)
-          next_line.blank?
+          body_end?(next_line.lstrip) || next_line.blank?
         end
 
         def empty_lines_around?(node)
@@ -61,6 +61,10 @@ module RuboCop
           %w(class module).any? { |keyword| line.start_with?(keyword) }
         end
 
+        def body_end?(line)
+          line.start_with?('end')
+        end
+
         def message(node)
           format(MSG, node.loc.selector.source)
         end

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

@@ -3,9 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks whether the source file has a utf-8 encoding comment or
-      # not. This check makes sense only in Ruby 1.9, since in 2.0+ utf-8 is
-      # the default source file encoding. There are two style:
+      # This cop checks whether the source file has a utf-8 encoding
+      # comment or not. This check makes sense only for code that
+      # should support Ruby 1.9, since in 2.0+ utf-8 is the default
+      # source file encoding. There are two style:
       #
       # when_needed - only enforce an encoding comment if there are non ASCII
       #               characters, otherwise report an offense
@@ -17,7 +18,6 @@ module RuboCop
         MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
 
         def investigate(processed_source)
-          return if RUBY_VERSION >= '2.0.0'
           return if processed_source.buffer.source.empty?
 
           line_number = encoding_line_number(processed_source)

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

@@ -30,12 +30,22 @@ module RuboCop
           end
         end
 
+        def format_method?(name, node)
+          receiver, method_name, args = *node
+
+          # we do an argument count check to reduce false positives
+          return false if args && args.children.size < 2
+
+          # commands have no explicit receiver
+          !receiver && method_name == name
+        end
+
         def format?(node)
-          command?(:format, node)
+          format_method?(:format, node)
         end
 
         def sprintf?(node)
-          command?(:sprintf, node)
+          format_method?(:sprintf, node)
         end
 
         def percent?(node)

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

@@ -14,17 +14,14 @@ module RuboCop
           ' Another good alternative is the usage of control flow `&&`/`||`.'
         end
 
-        def investigate(processed_source)
-          return unless processed_source.ast
-          on_node(:if, processed_source.ast) do |node|
-            # discard ternary ops, if/else and modifier if/unless nodes
-            next if ternary_op?(node)
-            next if modifier_if?(node)
-            next if elsif?(node)
-            next if if_else?(node)
-            next unless fit_within_line_as_modifier_form?(node)
-            add_offense(node, :keyword, message(node.loc.keyword.source))
-          end
+        def on_if(node)
+          # discard ternary ops, if/else and modifier if/unless nodes
+          return if ternary_op?(node)
+          return if modifier_if?(node)
+          return if elsif?(node)
+          return if if_else?(node)
+          return unless fit_within_line_as_modifier_form?(node)
+          add_offense(node, :keyword, message(node.loc.keyword.source))
         end
       end
     end

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Use `Kernel#loop` for infinite loops.
+      #
+      # @example
+      #   # bad
+      #   while true
+      #     work
+      #   end
+      #
+      #   # good
+      #   loop do
+      #     work
+      #   end
+      class InfiniteLoop < Cop
+        MSG = 'Use `Kernel#loop` for infinite loops.'
+
+        TRUTHY_LITERALS = [:str, :dstr, :int, :float, :array,
+                           :hash, :regexp, :true]
+
+        FALSEY_LITERALS = [:nil, :false]
+
+        def on_while(node)
+          condition, = *node
+
+          return unless TRUTHY_LITERALS.include?(condition.type)
+
+          add_offense(node, :keyword)
+        end
+
+        def on_until(node)
+          condition, = *node
+
+          return unless FALSEY_LITERALS.include?(condition.type)
+
+          add_offense(node, :keyword)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            condition_node, = *node
+            start_range = node.loc.keyword.begin
+            end_range = if node.loc.begin
+                          node.loc.begin.end
+                        else
+                          condition_node.loc.expression.end
+                        end
+            corrector.replace(start_range.join(end_range), 'loop do')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,24 +18,23 @@ module RuboCop
 
         def on_block(node)
           method, _args, _body = *node
-          on_node(:send, method) do |send_node|
+          method.each_node(:send) do |send_node|
             receiver, _method_name, *_args = *send_node
-            if receiver && receiver.type == :block
-              # The begin and end could also be braces, but we call the
-              # variables do... and end...
-              do_kw_loc, end_kw_loc = receiver.loc.begin, receiver.loc.end
+            next unless receiver && receiver.type == :block
 
-              if do_kw_loc.line != end_kw_loc.line
-                range =
-                  Parser::Source::Range.new(end_kw_loc.source_buffer,
-                                            end_kw_loc.begin_pos,
-                                            method.loc.expression.end_pos)
-                add_offense(nil, range)
-                # Done. If there are more blocks in the chain, they will be
-                # found by subsequent calls to on_block.
-                break
-              end
-            end
+            # The begin and end could also be braces, but we call the
+            # variables do... and end...
+            do_kw_loc, end_kw_loc = receiver.loc.begin, receiver.loc.end
+            next if do_kw_loc.line == end_kw_loc.line
+
+            range =
+              Parser::Source::Range.new(end_kw_loc.source_buffer,
+                                        end_kw_loc.begin_pos,
+                                        method.loc.expression.end_pos)
+            add_offense(nil, range)
+            # Done. If there are more blocks in the chain, they will be
+            # found by subsequent calls to on_block.
+            break
           end
         end
       end

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

@@ -44,6 +44,16 @@ module RuboCop
         def message(node)
           "Never use `then` for multi-line `#{node.loc.keyword.source}`."
         end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            condition_node, = *node
+            end_of_condition_range = condition_node.loc.expression.end
+            then_range = node.loc.begin
+            whitespaces_and_then_range = end_of_condition_range.join(then_range)
+            corrector.remove(whitespaces_and_then_range)
+          end
+        end
       end
     end
   end

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

@@ -14,9 +14,9 @@ module RuboCop
           # discard non-ternary ops
           return unless loc.respond_to?(:question)
 
-          node.children.each do |child|
-            on_node(:if, child) do |c|
-              add_offense(c, :expression) if c.loc.respond_to?(:question)
+          node.each_descendant(:if) do |nested_if_node|
+            if nested_if_node.loc.respond_to?(:question)
+              add_offense(nested_if_node, :expression)
             end
           end
         end

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

@@ -80,7 +80,9 @@ module RuboCop
           when String
             ''
           when Parser::AST::Node
-            /(\s*)/.match(object.loc.send(part).source_line)[1]
+            part_range = object.loc.send(part)
+            left_of_part = part_range.source_line[0...part_range.column]
+            /^(\s*)$/.match(left_of_part) ? left_of_part : ''
           else
             fail "Unsupported object #{object}"
           end

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

@@ -23,21 +23,39 @@ module RuboCop
         private
 
         def on_method(node, method_name, _args, _body)
-          prefix_blacklist.each do |prefix|
-            next unless method_name.to_s.start_with?(prefix)
-            add_offense(node, :name, message(method_name.to_s, prefix))
+          predicate_prefices.each do |prefix|
+            method_name = method_name.to_s
+            next unless method_name.start_with?(prefix)
+            next if method_name == expected_name(method_name, prefix)
+            add_offense(
+              node,
+              :name,
+              message(method_name, expected_name(method_name, prefix))
+            )
           end
         end
 
-        def message(method_name, prefix)
-          new_name = method_name.sub(prefix, '')
+        def expected_name(method_name, prefix)
+          new_name = if prefix_blacklist.include?(prefix)
+                       method_name.sub(prefix, '')
+                     else
+                       method_name.dup
+                     end
           new_name << '?' unless method_name.end_with?('?')
+          new_name
+        end
+
+        def message(method_name, new_name)
           "Rename `#{method_name}` to `#{new_name}`."
         end
 
         def prefix_blacklist
           cop_config['NamePrefixBlacklist']
         end
+
+        def predicate_prefices
+          cop_config['NamePrefix']
+        end
       end
     end
   end

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

@@ -41,7 +41,7 @@ module RuboCop
               range_with_surrounding_space(node.loc.expression),
               range_with_surrounding_space(
                 child.loc.expression
-              ).source.gsub(/^\s{#{indent_diff}}/, '')
+              ).source.gsub(/^[ \t]{#{indent_diff}}/, '')
             )
           end
         end

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

@@ -51,7 +51,7 @@ module RuboCop
         end
 
         def args_match?(method_name, args)
-          actual_args = args.flat_map { |a| a.to_a }
+          actual_args = args.flat_map(&:to_a)
 
           actual_args == target_args(method_name).map(&:to_sym)
         end

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

@@ -9,14 +9,10 @@ module RuboCop
         include SurroundingSpace
         include ConfigurableEnforcedStyle
 
-        def investigate(processed_source)
-          return unless processed_source.ast
-          @processed_source = processed_source
-          on_node(:optarg, processed_source.ast) do |optarg|
-            index = index_of_first_token(optarg)
-            arg, equals, value = processed_source.tokens[index, 3]
-            check_optarg(arg, equals, value)
-          end
+        def on_optarg(node)
+          index = index_of_first_token(node)
+          arg, equals, value = processed_source.tokens[index, 3]
+          check_optarg(arg, equals, value)
         end
 
         private

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

@@ -11,18 +11,16 @@ module RuboCop
 
         MSG = 'Space inside %s.'
 
-        def investigate(processed_source)
-          return unless processed_source.ast
+        def on_hash(node)
+          b_ix = index_of_first_token(node)
           tokens = processed_source.tokens
 
-          on_node(:hash, processed_source.ast) do |hash|
-            b_ix = index_of_first_token(hash)
-            if tokens[b_ix].type == :tLBRACE # Hash literal with braces?
-              e_ix = index_of_last_token(hash)
-              check(tokens[b_ix], tokens[b_ix + 1])
-              check(tokens[e_ix - 1], tokens[e_ix]) unless b_ix == e_ix - 1
-            end
-          end
+          # Hash literal with braces?
+          return unless tokens[b_ix].type == :tLBRACE
+
+          e_ix = index_of_last_token(node)
+          check(tokens[b_ix], tokens[b_ix + 1])
+          check(tokens[e_ix - 1], tokens[e_ix]) unless b_ix == e_ix - 1
         end
 
         private
@@ -69,7 +67,7 @@ module RuboCop
           @corrections << lambda do |corrector|
             # It is possible that BracesAroundHashParameters will remove the
             # braces while this cop inserts spaces. This can lead to unwanted
-            # changes to the inspected code.  If we replace the brace with a
+            # changes to the inspected code. If we replace the brace with a
             # brace plus space (rather than just inserting a space), then any
             # removal of the same brace will give us a clobbering error. This
             # in turn will make RuboCop fall back on cop-by-cop

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

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for spaces inside range literals.
+      # @example
+      #   # bad
+      #   1 .. 3
+      #
+      #   # good
+      #   1..3
+      #
+      #   # bad
+      #   'a' .. 'z'
+      #
+      #   # good
+      #   'a'..'z'
+      class SpaceInsideRangeLiteral < Cop
+        MSG = 'Space inside range literal.'
+
+        def on_irange(node)
+          check(node)
+        end
+
+        def on_erange(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          expression = node.loc.expression.source
+          operator = node.loc.operator.source.gsub(/\./, '\.')
+
+          return unless expression =~ /(\s#{operator})|(#{operator}\s)/
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          expression = node.loc.expression.source
+          operator = node.loc.operator.source
+          operator_escaped = operator.gsub(/\./, '\.')
+
+          @corrections << lambda do |corrector|
+            corrector.replace(
+              node.loc.expression,
+              expression
+                .sub(/\s+#{operator_escaped}/, operator)
+                .sub(/#{operator_escaped}\s+/, operator)
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -55,7 +55,7 @@ module RuboCop
             NON_ENGLISH_VARS.include? var
           end
 
-          # For now, we assume that lists are 2 items or less.  Easy grammar!
+          # For now, we assume that lists are 2 items or less. Easy grammar!
           regular_msg = regular.join('` or `')
           english_msg = english.join('` or `')
 

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

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Use symbols as procs when possible.
+      #
+      # @example
+      #   # bad
+      #   something.map { |s| s.upcase }
+      #
+      #   # good
+      #   something.map(&:upcase)
+      class SymbolProc < Cop
+        MSG = 'Pass `&:%s` as an argument to `%s` instead of a block.'
+
+        def on_block(node)
+          block_send, block_args, block_body = *node
+
+          _breceiver, bmethod_name, bargs = *block_send
+
+          # we should ignore lambdas
+          return if bmethod_name == :lambda
+          return if ignored_method?(bmethod_name)
+          # File.open(file) { |f| f.readlines }
+          return if bargs
+          # something { |x, y| ... }
+          return unless block_args.children.size == 1
+          return unless block_body && block_body.type == :send
+
+          receiver, method_name, args = *block_body
+
+          # method in block must be invoked on a lvar without args
+          return if args
+          return if receiver.type != :lvar
+
+          block_arg_name, = *block_args.children.first
+          receiver_name, = *receiver
+
+          return if block_arg_name != receiver_name
+
+          add_offense(node,
+                      :expression,
+                      format(MSG,
+                             method_name,
+                             bmethod_name))
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            block_method, _block_args, block_body = *node
+            _receiver, method_name, _args = *block_body
+
+            replacement = "#{block_method.loc.expression.source}" \
+                          "(&:#{method_name})"
+
+            corrector.replace(node.loc.expression, replacement)
+          end
+        end
+
+        def ignored_methods
+          cop_config['IgnoredMethods']
+        end
+
+        def ignored_method?(name)
+          ignored_methods.include?(name.to_s)
+        end
+      end
+    end
+  end
+end