rubocop 0.42.0 → 0.43.0

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

@@ -4,7 +4,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where Fixnum#even? or Fixnum#odd?
+      # This cop checks for places where Integer#even? or Integer#odd?
       # should have been used.
       #
       # @example
@@ -15,20 +15,25 @@ module RuboCop
       #   # good
       #   if x.even?
       class EvenOdd < Cop
-        MSG = 'Replace with `Fixnum#%s?`.'.freeze
+        MSG = 'Replace with `Integer#%s?`.'.freeze
 
         ZERO = s(:int, 0)
         ONE = s(:int, 1)
         TWO = s(:int, 2)
 
+        EQUALITY_OPERATORS = [:==, :!=].freeze
+
         def on_send(node)
-          offense = offense_type(node)
-          add_offense(node, :expression, format(MSG, offense)) if offense
+          offense_type(node) do |replacement_method|
+            add_offense(node, :expression, format(MSG, replacement_method))
+          end
         end
 
         def autocorrect(node)
-          correction = "#{base_number(node)}.#{offense_type(node)}?"
-          ->(corrector) { corrector.replace(node.source_range, correction) }
+          offense_type(node) do |replacement_method|
+            correction = "#{base_number(node)}.#{replacement_method}?"
+            ->(corrector) { corrector.replace(node.source_range, correction) }
+          end
         end
 
         private
@@ -36,20 +41,20 @@ module RuboCop
         def base_number(node)
           receiver, = *node
           node = expression(receiver)
-          node.children[0].source
+          node.children.first.source
         end
 
         def offense_type(node)
           receiver, method, args = *node
 
-          return unless [:==, :!=].include?(method)
+          return unless equality_operator?(method)
           return unless div_by_2?(receiver)
 
-          if args == ZERO
-            method == :== ? :even : :odd
-          elsif args == ONE
-            method == :== ? :odd : :even
-          end
+          replacement_method(args, method) { |odd_or_even| yield odd_or_even }
+        end
+
+        def equality_operator?(method_name)
+          EQUALITY_OPERATORS.include?(method_name)
         end
 
         def div_by_2?(node)
@@ -60,15 +65,21 @@ module RuboCop
           method == :% && args == TWO
         end
 
+        def replacement_method(args, method)
+          if args == ZERO
+            yield method == :== ? :even : :odd
+          elsif args == ONE
+            yield method == :== ? :odd : :even
+          end
+        end
+
         def expression(node)
           return unless node
 
           # check for scenarios like (x % 2) == 0
-          if node.type == :begin && node.children.size == 1
-            node = node.children.first
-          end
+          node = node.children.first if node.begin_type? && node.children.one?
 
-          return unless node.type == :send
+          return unless node.send_type?
           node
         end
       end

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

@@ -30,14 +30,7 @@ module RuboCop
           return if processed_source.ast.nil?
 
           if force_equal_sign_alignment?
-            @asgn_tokens = processed_source.tokens.select { |t| equal_sign?(t) }
-            # we don't want to operate on equals signs which are part of an
-            #   optarg in a method definition
-            # e.g.: def method(optarg = default_val); end
-            @asgn_tokens = remove_optarg_equals(@asgn_tokens, processed_source)
-
-            # Only attempt to align the first = on each line
-            @asgn_tokens = Set.new(@asgn_tokens.uniq { |t| t.pos.line })
+            @asgn_tokens = assignment_tokens
             @asgn_lines  = @asgn_tokens.map { |t| t.pos.line }
             # Don't attempt to correct the same = more than once
             @corrected   = Set.new
@@ -51,7 +44,7 @@ module RuboCop
         def autocorrect(range)
           lambda do |corrector|
             if range.source.end_with?('=')
-              align_equal_sign(range, corrector)
+              align_equal_signs(range, corrector)
             else
               corrector.remove(range)
             end
@@ -60,6 +53,17 @@ module RuboCop
 
         private
 
+        def assignment_tokens
+          tokens = processed_source.tokens.select { |t| equal_sign?(t) }
+          # we don't want to operate on equals signs which are part of an
+          #   optarg in a method definition
+          # e.g.: def method(optarg = default_val); end
+          tokens = remove_optarg_equals(tokens, processed_source)
+
+          # Only attempt to align the first = on each line
+          Set.new(tokens.uniq { |t| t.pos.line })
+        end
+
         def check_tokens(ast, t1, t2)
           return if t2.type == :tNL
 
@@ -100,20 +104,24 @@ module RuboCop
         end
 
         def check_other(t1, t2, ast)
+          extra_space_range(t1, t2) do |range|
+            # Unary + doesn't appear as a token and needs special handling.
+            next if ignored_range?(ast, range.begin_pos)
+            next if unary_plus_non_offense?(range)
+
+            add_offense(range, range, MSG_UNNECESSARY)
+          end
+        end
+
+        def extra_space_range(t1, t2)
           return if t1.pos.line != t2.pos.line
           return if allow_for_alignment? && aligned_tok?(t2)
 
           start_pos = t1.pos.end_pos
           end_pos = t2.pos.begin_pos - 1
           return if end_pos <= start_pos
-          return if ignored_range?(ast, start_pos)
-
-          range = Parser::Source::Range.new(processed_source.buffer,
-                                            start_pos, end_pos)
-          # Unary + doesn't appear as a token and needs special handling.
-          return if unary_plus_non_offense?(range)
 
-          add_offense(range, range, MSG_UNNECESSARY)
+          yield range_between(start_pos, end_pos)
         end
 
         def aligned_tok?(token)
@@ -172,22 +180,25 @@ module RuboCop
           token.type == :tEQL || token.type == :tOP_ASGN
         end
 
-        def align_equal_sign(range, corrector)
+        def align_equal_signs(range, corrector)
           lines  = contiguous_assignment_lines(range)
           tokens = @asgn_tokens.select { |t| lines.include?(t.pos.line) }
 
           columns  = tokens.map { |t| align_column(t) }
           align_to = columns.max
 
-          tokens.each do |token|
-            next unless @corrected.add?(token)
-            diff = align_to - token.pos.last_column
+          tokens.each { |token| align_equal_sign(corrector, token, align_to) }
+        end
+
+        def align_equal_sign(corrector, token, align_to)
+          return unless @corrected.add?(token)
 
-            if diff > 0
-              corrector.insert_before(token.pos, ' ' * diff)
-            elsif diff < 0
-              corrector.remove_preceding(token.pos, -diff)
-            end
+          diff = align_to - token.pos.last_column
+
+          if diff > 0
+            corrector.insert_before(token.pos, ' ' * diff)
+          elsif diff < 0
+            corrector.remove_preceding(token.pos, -diff)
           end
         end
 

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

@@ -97,16 +97,7 @@ module RuboCop
         end
 
         def match_namespace(node, namespace, expected)
-          expected = expected.dup
-
-          match_partial = lambda do |ns|
-            next if ns.nil?
-            while ns
-              return expected.empty? || expected == [:Object] if ns.cbase_type?
-              ns, name = *ns
-              name == expected.last ? expected.pop : (return false)
-            end
-          end
+          match_partial = partial_matcher!(expected)
 
           match_partial.call(namespace)
 
@@ -115,6 +106,24 @@ module RuboCop
             match_partial.call(ancestor.defined_module)
           end
 
+          match?(expected)
+        end
+
+        def partial_matcher!(expected)
+          lambda do |namespace|
+            while namespace
+              return match?(expected) if namespace.cbase_type?
+
+              namespace, name = *namespace
+
+              expected.pop if name == expected.last
+            end
+
+            false
+          end
+        end
+
+        def match?(expected)
           expected.empty? || expected == [:Object]
         end
 

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

@@ -74,9 +74,8 @@ module RuboCop
         end
 
         def base_range(send_node, arg_node)
-          Parser::Source::Range.new(processed_source.buffer,
-                                    send_node.source_range.begin_pos,
-                                    arg_node.source_range.begin_pos)
+          range_between(send_node.source_range.begin_pos,
+                        arg_node.source_range.begin_pos)
         end
 
         # Returns the column of the given range. For single line ranges, this

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

@@ -26,23 +26,27 @@ module RuboCop
           return if block_length(node).zero?
 
           method, _args, _body = *node
-          return unless method.type == :send
+          return unless method.send_type?
 
           _receiver, method_name, *args = *method
           return unless method_name == :each && args.empty?
 
           if style == :for
-            end_pos = method.source_range.end_pos
-            range = Parser::Source::Range.new(processed_source.buffer,
-                                              end_pos - EACH_LENGTH,
-                                              end_pos)
-            add_offense(range, range, 'Prefer `for` over `each`.') do
-              opposite_style_detected
-            end
+            incorrect_style_detected(method)
           else
             correct_style_detected
           end
         end
+
+        private
+
+        def incorrect_style_detected(method)
+          end_pos = method.source_range.end_pos
+          range = range_between(end_pos - EACH_LENGTH, end_pos)
+          add_offense(range, range, 'Prefer `for` over `each`.') do
+            opposite_style_detected
+          end
+        end
       end
     end
   end

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

@@ -54,7 +54,7 @@ module RuboCop
 
           method_name == :% &&
             ([:str, :dstr].include?(receiver_node.type) ||
-             arg_nodes[0].type == :array)
+             arg_nodes.first.array_type?)
         end
 
         def message(node)

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

@@ -37,94 +37,60 @@ module RuboCop
       #   raise 'exception' if something
       #   ok
       class GuardClause < Cop
-        include ConfigurableEnforcedStyle
         include IfNode
         include MinBodyLength
 
         MSG = 'Use a guard clause instead of wrapping the code inside a ' \
               'conditional expression.'.freeze
 
-        def_node_matcher :single_line_control_flow_exit?, <<-PATTERN
-          [{(send nil {:raise :fail} ...) return break next} single_line?]
-        PATTERN
-
         def on_def(node)
           _, _, body = *node
+
           return unless body
 
-          if if?(body)
-            check_trailing_if(body)
+          if body.if_type?
+            check_ending_if(body)
           elsif body.begin_type?
-            last_expr = body.children.last
-            check_trailing_if(last_expr) if if?(last_expr)
+            check_ending_if(body.children.last)
           end
         end
 
         def on_if(node)
-          return if accept_form?(node)
-          return unless any_single_line_control_flow_exit?(node)
-          return if line_too_long_when_corrected?(node)
+          return if accepted_form?(node) || !contains_guard_clause?(node)
 
           add_offense(node, :keyword, MSG)
         end
 
         private
 
-        def accept_form?(node)
-          cond, body, else_body = *node
-          return true unless body && else_body
-          return true if modifier_if?(node) || ternary?(node) || elsif?(node)
-
-          cond.multiline?
-        end
-
-        def any_single_line_control_flow_exit?(node)
-          _cond, body, else_body = *node
-
-          single_line_control_flow_exit?(body) ||
-            single_line_control_flow_exit?(else_body)
-        end
+        def check_ending_if(node)
+          return if !node.if_type? ||
+                    accepted_form?(node, true) ||
+                    !min_body_length?(node)
 
-        def if?(node)
-          node && node.if_type?
-        end
-
-        def elsif?(node)
-          return false unless node.parent && node.parent.if_type?
-          _condition, _if_branch, else_branch = *node.parent
-          else_branch.equal?(node)
+          add_offense(node, :keyword, MSG)
         end
 
-        def check_trailing_if(node)
-          cond, body, else_body = *node
+        def accepted_form?(node, ending = false)
+          condition, = *node
 
-          return if body && else_body
-          # discard modifier ifs and ternary_ops
-          return if modifier_if?(node) || ternary?(node)
-          return if cond.multiline?
-          # discard short ifs
-          return unless min_body_length?(node)
-          return if line_too_long_when_corrected?(node)
-
-          add_offense(node, :keyword, MSG)
+          ignored_node?(node, ending) || condition.multiline?
         end
 
-        def line_too_long_when_corrected?(node)
-          cond, body, else_body = *node
+        def ignored_node?(node, ending)
+          return true if modifier_if?(node) || ternary?(node)
 
-          if single_line_control_flow_exit?(body) || !else_body
-            line_too_long?(node, body, 'if', cond)
+          if ending
+            if_else?(node)
           else
-            line_too_long?(node, else_body, 'unless', cond)
+            !if_else?(node) || elsif?(node)
           end
         end
 
-        def line_too_long?(node, body, keyword, condition)
-          max    = config.for_cop('Metrics/LineLength')['Max'] || 80
-          indent = node.loc.column
-          source = body && body.source || ''
-          # 2 is for spaces on left and right of keyword
-          indent + (source + keyword + condition.source).length + 2 > max
+        def contains_guard_clause?(node)
+          _, body, else_body = *node
+
+          guard_clause?(body) || guard_clause?(else_body)
         end
       end
     end

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

@@ -10,11 +10,64 @@ module RuboCop
       # the use of the newer Ruby 1.9 syntax (when applicable).
       #
       # A separate offense is registered for each problematic pair.
+      #
+      # The supported styles are:
+      #
+      # * ruby19 - forces use of the 1.9 syntax (e.g. {a: 1}) when hashes have
+      #   all symbols for keys
+      # * hash_rockets - forces use of hash rockets for all hashes
+      # * no_mixed_keys - simply checks for hashes with mixed syntaxes
+      # * ruby19_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
+      #   syntax hashes
+      #
+      # @example
+      #   "EnforcedStyle => 'ruby19'"
+      #
+      #   @good
+      #   {a: 2, b: 1}
+      #   {:c => 2, 'd' => 2} # acceptable since 'd' isn't a symbol
+      #   {d: 1, 'e' => 2} # technically not forbidden
+      #
+      #   @bad
+      #   {:a => 2}
+      #   {b: 1, :c => 2}
+      #
+      # @example
+      #   "EnforcedStyle => 'hash_rockets'"
+      #
+      #   @good
+      #   {:a => 1, :b => 2}
+      #
+      #   @bad
+      #   {a: 1, b: 2}
+      #   {c: 1, 'd' => 5}
+      #
+      # @example
+      #   "EnforcedStyle => 'no_mixed_keys'"
+      #
+      #   @good
+      #   {:a => 1, :b => 2}
+      #   {c: 1, d: 2}
+      #
+      #   @bad
+      #   {:a => 1, b: 2}
+      #   {c: 1, 'd' => 2}
+      #
+      # @example
+      #   "EnforcedStyle => 'ruby19_no_mixed_keys'"
+      #
+      #   @good
+      #   {a: 1, b: 2}
+      #   {:c => 3, 'd' => 4}
+      #
+      #   @bad
+      #   {:a => 1, :b => 2}
+      #   {c: 2, 'd' => 3} # should just use hash rockets
       class HashSyntax < Cop
         include ConfigurableEnforcedStyle
 
         MSG_19 = 'Use the new Ruby 1.9 hash syntax.'.freeze
-        MSG_RUBY19_NO_MIXED_KEYS = "Don't mix styles in the same hash.".freeze
+        MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash.".freeze
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'.freeze
 
         @force_hash_rockets = false
@@ -29,6 +82,8 @@ module RuboCop
             hash_rockets_check(node)
           elsif style == :ruby19_no_mixed_keys
             ruby19_no_mixed_keys_check(node)
+          elsif style == :no_mixed_keys
+            no_mixed_keys_check(node)
           else
             ruby19_check(node)
           end
@@ -54,7 +109,18 @@ module RuboCop
           elsif sym_indices?(pairs)
             check(pairs, '=>', MSG_19)
           else
-            check(pairs, ':', MSG_RUBY19_NO_MIXED_KEYS)
+            check(pairs, ':', MSG_NO_MIXED_KEYS)
+          end
+        end
+
+        def no_mixed_keys_check(node)
+          pairs = *node
+
+          if !sym_indices?(pairs)
+            check(pairs, ':', MSG_NO_MIXED_KEYS)
+          else
+            delim = pairs.first.loc.operator.source == ':' ? '=>' : ':'
+            check(pairs, delim, MSG_NO_MIXED_KEYS)
           end
         end
 
@@ -62,8 +128,8 @@ module RuboCop
           lambda do |corrector|
             if style == :hash_rockets || @force_hash_rockets
               autocorrect_hash_rockets(corrector, node)
-            elsif style == :ruby19_no_mixed_keys
-              autocorrect_ruby19_no_mixed_keys(corrector, node)
+            elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
+              autocorrect_no_mixed_keys(corrector, node)
             else
               autocorrect_ruby19(corrector, node)
             end
@@ -134,8 +200,7 @@ module RuboCop
           key = node.children.first.source_range
           op = node.loc.operator
 
-          range = Parser::Source::Range.new(key.source_buffer,
-                                            key.begin_pos, op.end_pos)
+          range = range_between(key.begin_pos, op.end_pos)
           range = range_with_surrounding_space(range, :right)
           corrector.replace(range,
                             range.source.sub(/^:(.*\S)\s*=>\s*$/, '\1: '))
@@ -150,7 +215,7 @@ module RuboCop
           corrector.remove(range_with_surrounding_space(op))
         end
 
-        def autocorrect_ruby19_no_mixed_keys(corrector, node)
+        def autocorrect_no_mixed_keys(corrector, node)
           op = node.loc.operator
 
           if op.is?(':')