rubocop 0.34.2 → 0.35.0

data/lib/rubocop/cop/mixin/configurable_max.rb

@@ -6,7 +6,7 @@ module RuboCop
     # appropriate value with --auto-gen-config.
     module ConfigurableMax
       def max=(value)
-        cfg = self.config_to_allow_offenses ||= {}
+        cfg = config_to_allow_offenses
         value = [cfg[parameter_name], value].max if cfg[parameter_name]
         cfg[parameter_name] = value
       end

data/lib/rubocop/cop/mixin/configurable_naming.rb

@@ -33,7 +33,7 @@ module RuboCop
         return false unless node.defs_type?
         return false unless node.parent
 
-        node.parent.children.any? do |c|
+        node.parent.children.compact.any? do |c|
           c.class_type? && c.loc.name.is?(name.to_s)
         end
       end

data/lib/rubocop/cop/mixin/first_element_line_break.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    # Common functionality for checking for a line break before the first
+    # element in a multi-line collection.
+    module FirstElementLineBreak
+      def autocorrect(node)
+        ->(corrector) { corrector.insert_before(node.loc.expression, "\n") }
+      end
+
+      private
+
+      def check_method_line_break(node, children)
+        return if children.empty?
+
+        return unless method_uses_parens?(node, children.first)
+
+        check_children_line_break(node, children)
+      end
+
+      def method_uses_parens?(node, limit)
+        source = node.loc.expression.source_line[0...limit.loc.column]
+        source =~ /\s*\(\s*$/
+      end
+
+      def check_children_line_break(node, children, start = node)
+        return if children.size < 2
+
+        line = start.loc.line
+        min = children.min_by { |n| n.loc.first_line }
+        return if line != min.loc.first_line
+
+        max = children.max_by { |n| n.loc.last_line }
+        return if line == max.loc.last_line
+
+        add_offense(min, :expression, self.class::MSG)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/negative_conditional.rb

@@ -8,7 +8,7 @@ module RuboCop
       def check_negative_conditional(node)
         condition, _body, _rest = *node
 
-        # Look at last expression of contents if there's a parenthesis
+        # Look at last expression of contents if there are parentheses
         # around condition.
         condition = condition.children.last while condition.type == :begin
         return unless condition.type == :send

data/lib/rubocop/cop/mixin/safe_assignment.rb

@@ -6,21 +6,10 @@ module RuboCop
     # putting parentheses around an assignment to indicate "I know I'm using an
     # assignment as a condition. It's not a mistake."
     module SafeAssignment
-      def safe_assignment?(node)
-        return false unless node.type == :begin
-        return false unless node.children.size == 1
+      extend NodePattern::Macros
 
-        child = node.children.first
-        case child.type
-        when :send
-          _receiver, method_name, _args = *child
-          method_name.to_s.end_with?('=')
-        when *Util::EQUALS_ASGN_NODES
-          true
-        else
-          false
-        end
-      end
+      def_node_matcher :safe_assignment?,
+                       '(begin {equals_asgn? asgn_method_call?})'
 
       def safe_assignment_allowed?
         cop_config['AllowSafeAssignment']

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -30,7 +30,7 @@ module RuboCop
       end
 
       def max_line_length
-        cop_config && cop_config['MaxLineLength'] ||
+        cop_config['MaxLineLength'] ||
           config.for_cop('Metrics/LineLength')['Max']
       end
 
@@ -55,7 +55,7 @@ module RuboCop
       end
 
       def comment_lines
-        @comment_lines ||= processed_source.comments.map(&:location).map(&:line)
+        @comment_lines ||= processed_source.comments.map { |c| c.location.line }
       end
     end
   end

data/lib/rubocop/cop/performance/detect.rb

@@ -57,7 +57,11 @@ module RuboCop
                         else
                           preferred_method
                         end
-          first_range = node.loc.dot.join(node.loc.selector)
+
+          first_range = Parser::Source::Range.new(
+            receiver.loc.expression.source,
+            receiver.loc.end.end_pos,
+            receiver.loc.end.end_pos).join(node.loc.selector)
 
           receiver, _args, _body = *receiver if receiver.block_type?
 

data/lib/rubocop/cop/performance/fixed_size.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Performance
+      # Do not compute the size of statically sized objects.
+      class FixedSize < Cop
+        MSG = 'Do not compute the size of statically sized objects.'.freeze
+        COUNTERS = [:count, :length, :size].freeze
+        STATIC_SIZED_TYPES = [:array, :hash, :str, :sym].freeze
+
+        def on_send(node)
+          variable, method, arg = *node
+          return unless variable
+          return unless COUNTERS.include?(method)
+          return unless STATIC_SIZED_TYPES.include?(variable.type)
+          return if contains_splat?(variable)
+          return if contains_double_splat?(variable)
+          return if string_argument?(arg)
+          if node.parent
+            return if node.parent.casgn_type? || node.parent.block_type?
+          end
+          add_offense(node, :expression)
+        end
+
+        private
+
+        def contains_splat?(node)
+          return unless node.array_type?
+
+          node.children.any? do |child|
+            child.respond_to?(:splat_type?) && child.splat_type?
+          end
+        end
+
+        def contains_double_splat?(node)
+          return unless node.hash_type?
+
+          node.children.any? do |child|
+            child.respond_to?(:kwsplat_type?) && child.kwsplat_type?
+          end
+        end
+
+        def string_argument?(node)
+          node && !node.str_type?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/performance/size.rb

@@ -33,7 +33,7 @@ module RuboCop
           return unless method == :count
           return unless array?(receiver) || hash?(receiver)
           return if node.parent && node.parent.block_type?
-          return if args && args.block_pass_type?
+          return if args
 
           add_offense(node, node.loc.selector)
         end

data/lib/rubocop/cop/performance/string_replacement.rb

@@ -20,7 +20,7 @@ module RuboCop
       #   'a b c'.delete(' ')
       class StringReplacement < Cop
         MSG = 'Use `%s` instead of `%s`.'
-        DETERMINISTIC_REGEX = /^[\w\s\-,."']+$/.freeze
+        DETERMINISTIC_REGEX = /^[\w\s\-,"']+$/.freeze
         REGEXP_CONSTRUCTOR_METHODS = [:new, :compile].freeze
         GSUB_METHODS = [:gsub, :gsub!].freeze
         DETERMINISTIC_TYPES = [:regexp, :str, :send].freeze
@@ -32,16 +32,17 @@ module RuboCop
         def on_send(node)
           _string, method, first_param, second_param = *node
           return unless GSUB_METHODS.include?(method)
-          return unless second_param && second_param.str_type?
+          return unless string?(second_param)
           return unless DETERMINISTIC_TYPES.include?(first_param.type)
 
-          first_source = first_source(first_param)
+          first_source, options = first_source(first_param)
           second_source, = *second_param
 
           return if first_source.nil?
 
           if regex?(first_param)
             return unless first_source =~ DETERMINISTIC_REGEX
+            return if options
           end
 
           return if first_source.length != 1
@@ -53,7 +54,7 @@ module RuboCop
 
         def autocorrect(node)
           _string, method, first_param, second_param = *node
-          first_source = first_source(first_param)
+          first_source, = first_source(first_param)
           second_source, = *second_param
           replacement_method = replacement_method(method,
                                                   first_source,
@@ -74,17 +75,21 @@ module RuboCop
 
         private
 
+        def string?(node)
+          node && node.str_type?
+        end
+
         def first_source(first_param)
           case first_param.type
           when :regexp, :send
             return nil unless regex?(first_param)
 
-            source, = extract_source(first_param)
+            source, options = extract_source(first_param)
           when :str
             source, = *first_param
           end
 
-          source
+          [source, options]
         end
 
         def extract_source(node)
@@ -97,9 +102,10 @@ module RuboCop
         end
 
         def source_from_regex_literal(node)
-          regex, = *node
+          regex, options = *node
           source, = *regex
-          source
+          options, = *options
+          [source, options]
         end
 
         def source_from_regex_constructor(node)

data/lib/rubocop/cop/rails/pluralization_grammar.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for correct grammar when using ActiveSupport's
+      # core extensions to the numeric classes.
+      #
+      # @example
+      #   # bad
+      #   3.day.ago
+      #   1.months.ago
+      #
+      #   # good
+      #   3.days.ago
+      #   1.month.ago
+      class PluralizationGrammar < Cop
+        SINGULAR_DURATION_METHODS = { second: :seconds,
+                                      minute: :minutes,
+                                      hour: :hours,
+                                      day: :days,
+                                      week: :weeks,
+                                      fortnight: :fortnights,
+                                      month: :months,
+                                      year: :years }
+
+        PLURAL_DURATION_METHODS = SINGULAR_DURATION_METHODS.invert
+
+        MSG = 'Prefer `%s.%s`.'
+
+        def on_send(node)
+          receiver, method_name, *_args = *node
+          return if receiver.nil?
+          return unless duration_method?(method_name)
+          return unless literal_number?(receiver)
+          number, = *receiver
+          if singular_receiver?(number) && plural_method?(method_name)
+            add_offense(node,
+                        :expression,
+                        format(MSG, number, singularize(method_name)))
+          elsif plural_receiver?(number) && singular_method?(method_name)
+            add_offense(node,
+                        :expression,
+                        format(MSG, number, pluralize(method_name)))
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method_name = node.loc.selector.source
+            replacement = if plural_method?(method_name)
+                            singularize(method_name)
+                          else
+                            pluralize(method_name)
+                          end
+            corrector.replace(node.loc.selector, replacement)
+          end
+        end
+
+        def plural_method?(method_name)
+          method_name.to_s.end_with?('s')
+        end
+
+        def singular_method?(method_name)
+          !plural_method?(method_name)
+        end
+
+        def singular_receiver?(number)
+          number == 1
+        end
+
+        def plural_receiver?(number)
+          !singular_receiver?(number)
+        end
+
+        def literal_number?(node)
+          node.int_type? || node.float_type?
+        end
+
+        def pluralize(method_name)
+          SINGULAR_DURATION_METHODS.fetch(method_name.to_sym).to_s
+        end
+
+        def singularize(method_name)
+          PLURAL_DURATION_METHODS.fetch(method_name.to_sym).to_s
+        end
+
+        def duration_method?(method_name)
+          SINGULAR_DURATION_METHODS.key?(method_name) ||
+            PLURAL_DURATION_METHODS.key?(method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -156,7 +156,7 @@ module RuboCop
         def on_hash(node)
           return if ignored_node?(node)
           return if node.children.empty?
-          return unless multiline?(node)
+          return unless node.multiline?
 
           @alignment_for_hash_rockets ||=
             new_alignment('EnforcedHashRocketStyle')
@@ -201,17 +201,6 @@ module RuboCop
           node.loc.begin
         end
 
-        # Returns true if the hash spans multiple lines
-        def multiline?(node)
-          return false unless node.loc.expression.source.include?("\n")
-
-          return false if node.children[1..-1].all? do |child|
-            !begins_its_line?(child.loc.expression)
-          end
-
-          true
-        end
-
         def alignment_for(pair)
           if pair.loc.operator.is?('=>')
             @alignment_for_hash_rockets

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

@@ -3,23 +3,33 @@
 module RuboCop
   module Cop
     module Style
-      # Here we check if the parameters on a multi-line method call are
-      # aligned.
+      # Here we check if the parameters on a multi-line method call or
+      # definition are aligned.
       class AlignParameters < Cop
         include AutocorrectAlignment
-
-        MSG = 'Align the parameters of a method call if they span ' \
-              'more than one line.'
+        include OnMethodDef
 
         def on_send(node)
           _receiver, method, *args = *node
 
           return if method == :[]=
-          return if args.size <= 1
+          return if args.size < 2
+
+          check_alignment(args, base_column(node, args))
+        end
 
+        def on_method_def(node, _method_name, args, _body)
+          args = args.children
+          return if args.size < 2
           check_alignment(args, base_column(node, args))
         end
 
+        def message(node)
+          type = node.parent.send_type? ? 'call' : 'definition'
+          "Align the parameters of a method #{type} if they span " \
+          'more than one line.'
+        end
+
         private
 
         def fixed_indentation?
@@ -38,7 +48,9 @@ module RuboCop
         end
 
         def target_method_lineno(node)
-          if node.loc.selector
+          if node.def_type? || node.defs_type?
+            node.loc.keyword.line
+          elsif node.loc.selector
             node.loc.selector.line
           else
             # l.(1) has no selector, so we use the opening parenthesis instead

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

@@ -63,25 +63,54 @@ module RuboCop
           replacement = (node.type == :and ? '&&' : '||')
           lambda do |corrector|
             [expr1, expr2].each do |expr|
-              _receiver, _method_name, *args = *expr
-              next unless correctable?(expr)
-
-              sb = expr.loc.expression.source_buffer
-              begin_paren = expr.loc.selector.end_pos
-              end_paren = begin_paren + 1
-              range = Parser::Source::Range.new(sb, begin_paren, end_paren)
-              corrector.replace(range, '(')
-              corrector.insert_after(args.last.loc.expression, ')')
+              if expr.send_type?
+                correct_send(expr, corrector)
+              elsif expr.return_type?
+                correct_other(expr, corrector)
+              elsif expr.assignment?
+                correct_other(expr, corrector)
+              end
             end
             corrector.replace(node.loc.operator, replacement)
           end
         end
 
-        def correctable?(expr)
-          return false unless expr.type == :send
-          _receiver, method_name, *args = *expr
+        def correct_send(node, corrector)
+          receiver, method_name, *args = *node
+          if method_name == :!
+            # ! is a special case:
+            # 'x and !obj.method arg' can be auto-corrected if we
+            # recurse down a level and add parens to 'obj.method arg'
+            # however, 'not x' also parses as (send x :!)
+
+            if node.loc.selector.source == '!'
+              node = receiver
+              _receiver, _method_name, *args = *node
+            elsif node.loc.selector.source == 'not'
+              return correct_other(node, corrector)
+            else
+              fail 'unrecognized unary negation operator'
+            end
+          end
+          return unless correctable_send?(node)
+
+          sb = node.loc.expression.source_buffer
+          begin_paren = node.loc.selector.end_pos
+          range = Parser::Source::Range.new(sb, begin_paren, begin_paren + 1)
+          corrector.replace(range, '(')
+          corrector.insert_after(args.last.loc.expression, ')')
+        end
+
+        def correct_other(node, corrector)
+          return unless node.loc.expression.begin.source != '('
+          corrector.insert_before(node.loc.expression, '(')
+          corrector.insert_after(node.loc.expression, ')')
+        end
+
+        def correctable_send?(node)
+          _receiver, method_name, *args = *node
           # don't clobber if we already have a starting paren
-          return false unless !expr.loc.begin || expr.loc.begin.source != '('
+          return false unless !node.loc.begin || node.loc.begin.source != '('
           # don't touch anything unless we are sure it is a method call.
           return false unless args.last && method_name.to_s =~ /[a-z]/