rubocop 0.31.0 → 0.35.0

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

@@ -12,12 +12,12 @@ module RuboCop
       # The cop also reports warnings when you are using 'to_time' method,
       # because it doesn't know about Rails time zone too.
       #
-      # Two styles are supported for this cop. When EnforcedStyle is 'always'
+      # Two styles are supported for this cop. When EnforcedStyle is 'strict'
       # then the Date methods (today, current, yesterday, tomorrow)
       # are prohibited and the usage of both 'to_time'
       # and 'to_time_in_current_zone' is reported as warning.
       #
-      # When EnforcedStyle is 'acceptable' then only 'Date.today' is prohibited
+      # When EnforcedStyle is 'flexible' then only 'Date.today' is prohibited
       # and only 'to_time' is reported as warning.
       #
       # @example
@@ -33,29 +33,30 @@ module RuboCop
       #   Date.today
       #   date.to_time
       #
-      #   # reports offense only when style is 'always'
+      #   # reports offense only when style is 'strict'
       #   date.to_time_in_current_zone
       class Date < Cop
         include ConfigurableEnforcedStyle
 
         MSG = 'Do not use `%s` without zone. Use `%s` instead.'
 
-        MSG_SEND =  'Do not use `%s` on Date objects,' \
-                    'because it knows nothing about time zone in use.'
+        MSG_SEND =  'Do not use `%s` on Date objects, ' \
+                    'because they know nothing about the time zone in use.'
 
         BAD_DAYS = [:today, :current, :yesterday, :tomorrow]
 
         def on_const(node)
-          _, klass = *node.children
-
-          return unless method_send?(node)
+          mod, klass = *node.children
+          # we should only check core Date class (`Date` or `::Date`)
+          return unless (mod.nil? || mod.cbase_type?) && method_send?(node)
 
           check_date_node(node.parent) if klass == :Date
         end
 
         def on_send(node)
-          method_name = extract_method(node)
-          return unless bad_methods.include?(method_name)
+          receiver, method_name, *args = *node
+          return unless receiver && bad_methods.include?(method_name)
+          return if method_name == :to_time && args.length == 1
 
           add_offense(node, :selector,
                       format(MSG_SEND,
@@ -75,7 +76,7 @@ module RuboCop
           add_offense(node, :selector,
                       format(MSG,
                              "Date.#{method_name}",
-                             'Time.zone.today')
+                             "Time.zone.#{method_name}")
                      )
         end
 
@@ -96,7 +97,7 @@ module RuboCop
         # checks that parent node of send_type
         # and receiver is the given node
         def method_send?(node)
-          return false unless node.parent.send_type?
+          return false unless node.parent && node.parent.send_type?
 
           receiver, _method_name, *_args = *node.parent
 
@@ -104,7 +105,7 @@ module RuboCop
         end
 
         def good_days
-          style == :always ? [] : [:current, :yesterday, :tomorrow]
+          style == :strict ? [] : [:current, :yesterday, :tomorrow]
         end
 
         def bad_days
@@ -112,7 +113,7 @@ module RuboCop
         end
 
         def bad_methods
-          style == :always ? [:to_time, :to_time_in_current_zone] : [:to_time]
+          style == :strict ? [:to_time, :to_time_in_current_zone] : [:to_time]
         end
       end
     end

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/rails/read_write_attribute.rb

@@ -33,7 +33,7 @@ module RuboCop
           if method_name == :read_attribute
             format(MSG, 'self[:attr]', 'read_attribute(:attr)')
           else
-            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, var)')
+            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, val)')
           end
         end
 

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

@@ -8,10 +8,10 @@ module RuboCop
       # Built on top of Ruby on Rails style guide (https://github.com/bbatsov/rails-style-guide#time)
       # and the article http://danilenko.org/2012/7/6/rails_timezones/ .
       #
-      # Two styles are supported for this cop. When EnforcedStyle is 'always'
+      # Two styles are supported for this cop. When EnforcedStyle is 'strict'
       # then only use of Time.zone is allowed.
       #
-      # When EnforcedStyle is 'acceptable' then it's also allowed
+      # When EnforcedStyle is 'flexible' then it's also allowed
       # to use Time.in_time_zone.
       #
       # @example
@@ -24,6 +24,7 @@ module RuboCop
       #   Time.zone.parse('2015-03-02 19:05:37')
       #
       #   # no offense only if style is 'acceptable'
+      #   Time.current
       #   DateTime.strptime(str, "%Y-%m-%d %H:%M %Z").in_time_zone
       #   Time.at(timestamp).in_time_zone
       class TimeZone < Cop
@@ -35,18 +36,22 @@ module RuboCop
 
         MSG_LOCALTIME = 'Do not use `Time.localtime` without offset or zone.'
 
+        MSG_CURRENT = 'Do not use `%s`. Use `Time.zone.now` instead.'
+
         TIMECLASS = [:Time, :DateTime]
 
-        DANGER_METHODS = [:now, :local, :new, :strftime, :parse, :at]
+        DANGEROUS_METHODS = [:now, :local, :new, :strftime,
+                             :parse, :at, :current]
 
-        ACCEPTED_METHODS = [:in_time_zone, :utc,
+        ACCEPTED_METHODS = [:current, :in_time_zone, :utc, :getlocal,
                             :iso8601, :jisx0301, :rfc3339,
                             :to_i, :to_f]
 
         def on_const(node)
-          _module, klass = *node
-
-          return unless method_send?(node)
+          mod, klass = *node
+          # we should only check core class
+          # (`DateTime`/`Time` or `::Date`/`::DateTime`)
+          return unless (mod.nil? || mod.cbase_type?) && method_send?(node)
 
           check_time_node(klass, node.parent) if TIMECLASS.include?(klass)
         end
@@ -59,7 +64,9 @@ module RuboCop
 
           return check_localtime(node) if need_check_localtime?(chain)
 
-          method_name = (chain & DANGER_METHODS).join('.')
+          method_name = (chain & DANGEROUS_METHODS).join('.')
+
+          return if offset_provided?(node)
 
           message = build_message(klass, method_name, node)
 
@@ -68,19 +75,19 @@ module RuboCop
 
         def build_message(klass, method_name, node)
           if acceptable?
-            accepted_methods = ACCEPTED_METHODS.map do |am|
-              "`#{klass}.#{method_name}.#{am}`"
-            end
-
             format(MSG_ACCEPTABLE,
                    "#{klass}.#{method_name}",
-                   accepted_methods.join(', ')
+                   acceptable_methods(klass, method_name, node).join(', ')
+                  )
+          elsif method_name == 'current'
+            format(MSG_CURRENT,
+                   "#{klass}.#{method_name}"
                   )
           else
             safe_method_name = safe_method(method_name, node)
             format(MSG,
                    "#{klass}.#{method_name}",
-                   "#{klass}.zone.#{safe_method_name}"
+                   "Time.zone.#{safe_method_name}"
                   )
           end
         end
@@ -102,7 +109,7 @@ module RuboCop
         # checks that parent node of send_type
         # and receiver is the given node
         def method_send?(node)
-          return false unless node.parent.send_type?
+          return false unless node.parent && node.parent.send_type?
 
           receiver, _method_name, *_args = *node.parent
 
@@ -132,7 +139,7 @@ module RuboCop
         end
 
         def danger_chain?(chain)
-          (chain & DANGER_METHODS).empty? || !(chain & good_methods).empty?
+          (chain & DANGEROUS_METHODS).empty? || !(chain & good_methods).empty?
         end
 
         def need_check_localtime?(chain)
@@ -140,11 +147,32 @@ module RuboCop
         end
 
         def acceptable?
-          style == :acceptable
+          style == :flexible
         end
 
         def good_methods
-          style == :always ? [:zone] : [:zone] + ACCEPTED_METHODS
+          style == :strict ? [:zone] : [:zone] + ACCEPTED_METHODS
+        end
+
+        def acceptable_methods(klass, method_name, node)
+          acceptable = [
+            "`Time.zone.#{safe_method(method_name, node)}`"
+          ]
+
+          ACCEPTED_METHODS.each do |am|
+            acceptable << "`#{klass}.#{method_name}.#{am}`"
+          end
+
+          acceptable
+        end
+
+        # Time.new can be called with a time zone offset
+        # When it is, that should be considered safe
+        # Example:
+        # Time.new(1988, 3, 15, 3, 0, 0, "-05:00")
+        def offset_provided?(node)
+          _, _, *args = *node
+          args.length >= 7
         end
       end
     end

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

@@ -15,6 +15,7 @@ module RuboCop
           # using alias is the only option in certain scenarios
           # in such scenarios we don't want to report an offense
           return unless method_name == :instance_exec
+          return unless body
 
           body.each_node(:alias) { |n| ignore_node(n) }
         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
@@ -231,9 +220,13 @@ module RuboCop
           key, value = *node
 
           lambda do |corrector|
-            adjust(corrector, key_delta, key.loc.expression)
-            adjust(corrector, separator_delta, node.loc.operator)
-            adjust(corrector, value_delta, value.loc.expression)
+            if value.nil?
+              adjust(corrector, key_delta, node.loc.expression)
+            else
+              adjust(corrector, key_delta, key.loc.expression)
+              adjust(corrector, separator_delta, node.loc.operator)
+              adjust(corrector, value_delta, value.loc.expression)
+            end
           end
         end
 

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]/
 

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

@@ -25,7 +25,7 @@ module RuboCop
         ]
 
         def on_send(node)
-          receiver_node, method_name, *_arg_nodes = *node
+          receiver_node, method_name, *arg_nodes = *node
 
           TARGET_METHODS.each do |(target_class, target_method)|
             target_receiver = s(:const, nil, target_class)
@@ -33,6 +33,7 @@ module RuboCop
             next if receiver_node != target_receiver
             next if method_name != target_method
             next if node.parent && node.parent.block_type?
+            next if !arg_nodes.empty? && arg_nodes.last.block_pass_type?
 
             add_offense(node,
                         :expression,

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

@@ -6,6 +6,8 @@ module RuboCop
       # This cop looks for uses of block comments (=begin...=end).
       class BlockComments < Cop
         MSG = 'Do not use block comments.'
+        BEGIN_LENGTH = "=begin\n".length
+        END_LENGTH = "\n=end".length
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
@@ -33,9 +35,9 @@ module RuboCop
 
         def parts(comment)
           expr = comment.loc.expression
-          eq_begin = expr.resize("=begin\n".length)
+          eq_begin = expr.resize(BEGIN_LENGTH)
           eq_end = Parser::Source::Range.new(expr.source_buffer,
-                                             expr.end_pos - "\n=end".length,
+                                             expr.end_pos - END_LENGTH,
                                              expr.end_pos)
           contents = Parser::Source::Range.new(expr.source_buffer,
                                                eq_begin.end_pos,