rubocop 0.32.1 → 0.33.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
@@ -46,9 +46,9 @@ module RuboCop
         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
@@ -75,7 +75,7 @@ module RuboCop
           add_offense(node, :selector,
                       format(MSG,
                              "Date.#{method_name}",
-                             'Time.zone.today')
+                             "Time.zone.#{method_name}")
                      )
         end
 
@@ -104,7 +104,7 @@ module RuboCop
         end
 
         def good_days
-          style == :always ? [] : [:current, :yesterday, :tomorrow]
+          style == :strict ? [] : [:current, :yesterday, :tomorrow]
         end
 
         def bad_days
@@ -112,7 +112,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/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, :getlocal,
+        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,7 @@ module RuboCop
 
           return check_localtime(node) if need_check_localtime?(chain)
 
-          method_name = (chain & DANGER_METHODS).join('.')
+          method_name = (chain & DANGEROUS_METHODS).join('.')
 
           message = build_message(klass, method_name, node)
 
@@ -72,11 +77,15 @@ module RuboCop
                    "#{klass}.#{method_name}",
                    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
@@ -128,7 +137,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)
@@ -136,16 +145,16 @@ 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 = [
-            "`#{klass}.zone.#{safe_method(method_name, node)}`"
+            "`Time.zone.#{safe_method(method_name, node)}`"
           ]
 
           ACCEPTED_METHODS.each do |am|

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

@@ -155,7 +155,8 @@ module RuboCop
         def return_value_of_scope?(node)
           return unless node.parent
 
-          conditional?(node.parent) || node.parent.children.last == node
+          conditional?(node.parent) || array_or_range?(node.parent) ||
+            node.parent.children.last == node
         end
 
         def procedural_methods
@@ -173,6 +174,10 @@ module RuboCop
         def conditional?(node)
           node.if_type? || node.or_type? || node.and_type?
         end
+
+        def array_or_range?(node)
+          node.array_type? || node.irange_type? || node.erange_type?
+        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module RuboCop
       # This cop checks for missing top-level documentation of
       # classes and modules. Classes with no body are exempt from the
       # check and so are namespace modules - modules that have nothing in
-      # their bodies except classes or other other modules.
+      # their bodies except classes or other modules.
       #
       # The documentation requirement is annulled if the class or module has
       # a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the

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

@@ -7,19 +7,29 @@ module RuboCop
       #
       # @example
       #
-      #   name     = "RuboCop"
+      #   # good if AllowForAlignment is true
+      #   name      = "RuboCop"
+      #   # Some comment and an empty line
+      #
+      #   website  += "/bbatsov/rubocop" unless cond
+      #   puts        "rubocop"          if     debug
+      #
+      #   # bad for any configuration
+      #   set_app("RuboCop")
       #   website  = "https://github.com/bbatsov/rubocop"
       class ExtraSpacing < Cop
         MSG = 'Unnecessary spacing detected.'
 
         def investigate(processed_source)
           processed_source.tokens.each_cons(2) do |t1, t2|
-            next unless t1.pos.line == t2.pos.line
-            next unless t2.pos.begin_pos - 1 > t1.pos.end_pos
-            buffer = processed_source.buffer
+            next if t2.type == :tNL
+            next if t1.pos.line != t2.pos.line
+            next if t2.pos.begin_pos - 1 <= t1.pos.end_pos
+            next if allow_for_alignment? && aligned_with_something?(t2)
             start_pos = t1.pos.end_pos
             end_pos = t2.pos.begin_pos - 1
-            range = Parser::Source::Range.new(buffer, start_pos, end_pos)
+            range = Parser::Source::Range.new(processed_source.buffer,
+                                              start_pos, end_pos)
             add_offense(range, range, MSG)
           end
         end
@@ -27,6 +37,75 @@ module RuboCop
         def autocorrect(range)
           ->(corrector) { corrector.remove(range) }
         end
+
+        private
+
+        def allow_for_alignment?
+          cop_config['AllowForAlignment']
+        end
+
+        def aligned_with_something?(token)
+          return aligned_comments?(token) if token.type == :tCOMMENT
+
+          pre = (token.pos.line - 2).downto(0)
+          post = token.pos.line.upto(processed_source.lines.size - 1)
+          aligned_with?(pre, token) || aligned_with?(post, token)
+        end
+
+        def aligned_comments?(token)
+          ix = processed_source.comments.index do |c|
+            c.loc.expression.begin_pos == token.pos.begin_pos
+          end
+          aligned_with_previous_comment?(ix) || aligned_with_next_comment?(ix)
+        end
+
+        def aligned_with_previous_comment?(ix)
+          ix > 0 && comment_column(ix - 1) == comment_column(ix)
+        end
+
+        def aligned_with_next_comment?(ix)
+          ix < processed_source.comments.length - 1 &&
+            comment_column(ix + 1) == comment_column(ix)
+        end
+
+        def comment_column(ix)
+          processed_source.comments[ix].loc.column
+        end
+
+        def aligned_with?(indices_to_check, token)
+          indices_to_check.each do |ix|
+            next if comment_lines.include?(ix + 1)
+            line = processed_source.lines[ix]
+            next if line.strip.empty?
+            return (aligned_words?(token, line) ||
+                    aligned_assignments?(token, line) ||
+                    aligned_same_character?(token, line))
+          end
+          false # No line to check was found.
+        end
+
+        def comment_lines
+          @comment_lines ||=
+            begin
+              whole_line_comments = processed_source.comments.select do |c|
+                begins_its_line?(c.loc.expression)
+              end
+              whole_line_comments.map(&:loc).map(&:line)
+            end
+        end
+
+        def aligned_words?(token, line)
+          line[token.pos.column - 1, 2] =~ /\s\S/
+        end
+
+        def aligned_assignments?(token, line)
+          token.type == :tOP_ASGN &&
+            line[token.pos.column + token.text.length] == '='
+        end
+
+        def aligned_same_character?(token, line)
+          line[token.pos.column] == token.text[0]
+        end
       end
     end
   end

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

@@ -39,6 +39,8 @@ module RuboCop
         private
 
         def message(arg_node)
+          return 'Bad indentation of the first parameter.' if arg_node.nil?
+
           send_node = arg_node.parent
           text = base_range(send_node, arg_node).source.strip
           base = if text !~ /\n/ && special_inner_call_indentation?(send_node)

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

@@ -82,10 +82,11 @@ module RuboCop
         def on_send(node)
           super
           receiver, method_name, *args = *node
-          return unless visibility_and_def_on_same_line?(receiver, method_name,
-                                                         args)
+          return unless modifier_and_def_on_same_line?(receiver, method_name,
+                                                       args)
+
+          *_, body = *args.first
 
-          _method_name, _args, body = *args.first
           def_end_config = config.for_cop('Lint/DefEndAlignment')
           style = if def_end_config['Enabled']
                     def_end_config['AlignWith']
@@ -211,13 +212,36 @@ module RuboCop
             body_node = body_node.children.first
           end
 
+          # Since autocorrect changes a number of lines, and not only the line
+          # where the reported offending range is, we avoid auto-correction if
+          # this cop has already found other offenses is the same
+          # range. Otherwise, two corrections can interfere with each other,
+          # resulting in corrupted code.
+          node = if autocorrect? && other_offense_in_same_range?(body_node)
+                   nil
+                 else
+                   body_node
+                 end
+
           indentation_name = style == 'normal' ? '' : "#{style} "
-          add_offense(body_node, offending_range(body_node, indentation),
+          add_offense(node, offending_range(body_node, indentation),
                       format("Use #{configured_indentation_width} (not %d) " \
                              "spaces for #{indentation_name}indentation.",
                              indentation))
         end
 
+        # Returns true if the given node is within another node that has
+        # already been marked for auto-correction by this cop.
+        def other_offense_in_same_range?(node)
+          expr = node.loc.expression
+          @offense_ranges ||= []
+
+          return true if @offense_ranges.any? { |r| within?(expr, r) }
+
+          @offense_ranges << expr
+          false
+        end
+
         def indentation_to_check?(base_loc, body_node)
           return false unless body_node
 

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks for indentation of the first non-blank non-comment
+      # line in a file.
+      class InitialIndentation < Cop
+        MSG = 'Indentation of first line in file detected.'
+
+        def investigate(processed_source)
+          first_token = processed_source.tokens.find do |t|
+            !t.text.start_with?('#')
+          end
+          return unless first_token
+          return if first_token.pos.column == 0
+
+          with_space = range_with_surrounding_space(first_token.pos, :left,
+                                                    nil, !:with_newline)
+          space = Parser::Source::Range.new(processed_source.buffer,
+                                            with_space.begin_pos,
+                                            first_token.pos.begin_pos)
+          add_offense(space, first_token.pos)
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.remove(range) }
+        end
+      end
+    end
+  end
+end

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

@@ -7,13 +7,17 @@ module RuboCop
       class MethodCallParentheses < Cop
         MSG = 'Do not use parentheses for method calls with no arguments.'
 
+        ASGN_NODES = [:lvasgn, :masgn] + Util::SHORTHAND_ASGN_NODES
+
         def on_send(node)
           _receiver, method_name, *args = *node
 
           # methods starting with a capital letter should be skipped
           return if method_name =~ /\A[A-Z]/
+          return unless args.empty? && node.loc.begin
+          return if same_name_assignment?(node)
 
-          add_offense(node, :begin) if args.empty? && node.loc.begin
+          add_offense(node, :begin)
         end
 
         def autocorrect(node)
@@ -22,6 +26,21 @@ module RuboCop
             corrector.remove(node.loc.end)
           end
         end
+
+        private
+
+        def same_name_assignment?(node)
+          _receiver, method_name, *_args = *node
+
+          node.each_ancestor(ASGN_NODES).any? do |asgn_node|
+            if asgn_node.masgn_type?
+              mlhs_node, _mrhs_node = *asgn_node
+              asgn_node = mlhs_node.children[node.sibling_index]
+            end
+
+            asgn_node.loc.name.source == method_name.to_s
+          end
+        end
       end
     end
   end

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

@@ -8,12 +8,16 @@ module RuboCop
       class OneLineConditional < Cop
         include OnNormalIfUnless
 
-        MSG = 'Favor the ternary operator (?:) ' \
-              'over if/then/else/end constructs.'
+        MSG = 'Favor the ternary operator (`?:`) ' \
+              'over `%s/then/else/end` constructs.'
 
         def on_normal_if_unless(node)
-          return if node.loc.expression.source.include?("\n")
-          add_offense(node, :expression, MSG)
+          exp = node.loc.expression.source
+          return if exp.include?("\n")
+          return unless node.loc.respond_to?(:else) && node.loc.else
+          condition = exp.include?('if') ? 'if' : 'unless'
+
+          add_offense(node, :expression, format(MSG, condition))
         end
       end
     end