rubocop 0.16.0 → 0.17.0

data/lib/rubocop/cop/ignored_node.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Handles adding and checking ignored nodes.
+    module IgnoredNode
+      def ignore_node(node)
+        @ignored_nodes ||= []
+        @ignored_nodes << node
+      end
+
+      def part_of_ignored_node?(node)
+        return false unless @ignored_nodes
+        expression = node.loc.expression
+        @ignored_nodes.each do |ignored_node|
+          if ignored_node.loc.expression.begin_pos <= expression.begin_pos &&
+            ignored_node.loc.expression.end_pos >= expression.end_pos
+            return true
+          end
+        end
+
+        false
+      end
+
+      def ignored_node?(node)
+        # Same object found in array?
+        @ignored_nodes && @ignored_nodes.any? { |n| n.eql?(node) }
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/ambiguous_operator.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for ambiguous operators in the first argument of a
+      # method invocation without parentheses.
+      #
+      # @example
+      #   array = [1, 2, 3]
+      #
+      #   # The `*` is interpreted as a splat operator but it could possibly be
+      #   # a `*` method invocation (i.e. `do_something.*(array)`).
+      #   do_something *array
+      #
+      #   # With parentheses, there's no ambiguity.
+      #   do_something(*array)
+      class AmbiguousOperator < Cop
+        include ParserDiagnostic
+
+        AMBIGUITIES = {
+          '+'  => { actual: 'positive number', possible: 'addition' },
+          '-'  => { actual: 'negative number', possible: 'subtraction' },
+          '*'  => { actual: 'splat',           possible: 'multiplication' },
+          '&'  => { actual: 'block',           possible: 'binary AND' },
+          '**' => { actual: 'keyword splat',   possible: 'exponent' }
+        }.each do |key, hash|
+          hash[:operator] = key
+        end
+
+        MSG_FORMAT = 'Ambiguous %{actual} operator. Parenthesize the method ' +
+                     "arguments if it's surely a %{actual} operator, or add " +
+                     'a whitespace to the right of the %{operator} if it ' +
+                     'should be a %{possible}.'
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :ambiguous_prefix
+        end
+
+        def alternative_message(diagnostic)
+          operator = diagnostic.location.source
+          hash = AMBIGUITIES[operator]
+          format(MSG_FORMAT, hash)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for ambiguous regexp literals in the first argument of
+      # a method invocation without parentheses.
+      #
+      # @example
+      #   # This is interpreted as a method invocation with a regexp literal,
+      #   # but it could possibly be `/` method invocations.
+      #   # (i.e. `do_something./(pattern)./(i)`)
+      #   do_something /pattern/i
+      #
+      #   # With parentheses, there's no ambiguity.
+      #   do_something(/pattern/i)
+      class AmbiguousRegexpLiteral < Cop
+        include ParserDiagnostic
+
+        MSG = 'Ambiguous regexp literal. Parenthesize the method arguments ' +
+              "if it's surely a regexp literal, or add a whitespace to the " +
+              'right of the / if it should be a division.'
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :ambiguous_literal
+        end
+
+        def alternative_message(diagnostic)
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -6,7 +6,8 @@ module Rubocop
       # This cop checks for assignments in the conditions of
       # if/while/until.
       class AssignmentInCondition < Cop
-        ASGN_NODES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn]
+        include SafeAssignment
+
         MSG = 'Assignment in condition - you probably meant to use ==.'
 
         def on_if(node)
@@ -29,7 +30,7 @@ module Rubocop
           # assignments inside blocks are not what we're looking for
           return if condition.type == :block
 
-          on_node([:begin, *ASGN_NODES], condition) do |asgn_node|
+          on_node([:begin, *EQUALS_ASGN_NODES], condition) do |asgn_node|
             # skip safe assignment nodes if safe assignment is allowed
             return if safe_assignment_allowed? && safe_assignment?(asgn_node)
 
@@ -39,15 +40,6 @@ module Rubocop
             end
           end
         end
-
-        def safe_assignment?(node)
-          node.type == :begin && node.children.size == 1 &&
-            ASGN_NODES.include?(node.children[0].type)
-        end
-
-        def safe_assignment_allowed?
-          cop_config['AllowSafeAssignment']
-        end
       end
     end
   end

data/lib/rubocop/cop/lint/block_alignment.rb

@@ -12,6 +12,8 @@ module Rubocop
       #     i
       #   end
       class BlockAlignment < Cop
+        include CheckAssignment
+
         MSG = 'end at %d, %d is not aligned with %s at %d, %d%s'
 
         def initialize(config = nil, options = nil)
@@ -36,40 +38,24 @@ module Rubocop
 
         alias_method :on_or, :on_and
 
-        def on_lvasgn(node)
-          _, children = *node
-          process_block_assignment(node, children)
-        end
-
-        alias_method :on_ivasgn,   :on_lvasgn
-        alias_method :on_cvasgn,   :on_lvasgn
-        alias_method :on_gvasgn,   :on_lvasgn
-        alias_method :on_and_asgn, :on_lvasgn
-        alias_method :on_or_asgn,  :on_lvasgn
-
-        def on_casgn(node)
-          _, _, children = *node
-          process_block_assignment(node, children)
-        end
-
         def on_op_asgn(node)
           variable, _op, args = *node
-          process_block_assignment(variable, args)
+          check_assignment(variable, args)
         end
 
         def on_send(node)
           _receiver, _method, *args = *node
-          process_block_assignment(node, args.last)
+          check_assignment(node, args.last)
         end
 
         def on_masgn(node)
           variables, args = *node
-          process_block_assignment(variables, args)
+          check_assignment(variables, args)
         end
 
         private
 
-        def process_block_assignment(begin_node, other_node)
+        def check_assignment(begin_node, other_node)
           return unless other_node
 
           block_node = find_block_node(other_node)

data/lib/rubocop/cop/lint/condition_position.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for conditions that are not on the same line as
+      # if/while/until.
+      #
+      # @example
+      #
+      #   if
+      #     some_condition
+      #     do_something
+      #   end
+      class ConditionPosition < Cop
+        def on_if(node)
+          return if node.loc.respond_to?(:question)
+
+          check(node)
+        end
+
+        def on_while(node)
+          check(node)
+        end
+
+        def on_until(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          condition, = *node
+
+          if on_different_line?(node.loc.keyword.line,
+                                condition.loc.expression.line)
+            add_offence(condition, :expression,
+                        message(node.loc.keyword.source))
+          end
+        end
+
+        def message(keyword)
+          "Place the condition on the same line as #{keyword}."
+        end
+
+        def on_different_line?(keyword_line, cond_line)
+          keyword_line != cond_line
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/else_layout.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for odd else block layout - like
+      # having an expression on the same line as the else keyword,
+      # which is usually a mistake.
+      #
+      # @example
+      #
+      #   if something
+      #     ...
+      #   else do_this
+      #     do_that
+      #   end
+      class ElseLayout < Cop
+        def on_if(node)
+          # ignore ternary ops
+          return if node.loc.respond_to?(:question)
+          # ignore modifier ops & elsif nodes
+          return unless node.loc.end
+
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return unless node
+
+          if node.loc.respond_to?(:else) &&
+             node.loc.else &&
+             node.loc.else.is?('else')
+            _cond, _if_branch, else_branch = *node
+
+            return unless else_branch && else_branch.type == :begin
+
+            first_else_expr = else_branch.children.first
+
+            if first_else_expr.loc.expression.line == node.loc.else.line
+              add_offence(first_else_expr, :expression, message)
+            end
+          elsif node.loc.respond_to?(:keyword) &&
+                %w(if elsif).include?(node.loc.keyword.source)
+            _cond, _if_branch, else_branch = *node
+            check(else_branch)
+          end
+        end
+
+        def message
+          'Odd else layout detected. Perhaps you meant to use elsif instead?'
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/end_alignment.rb

@@ -18,6 +18,7 @@ module Rubocop
       class EndAlignment < Cop
         include CheckMethods
         include CheckAssignment
+        include ConfigurableEnforcedStyle
 
         MSG = 'end at %d, %d is not aligned with %s at %d, %d'
 
@@ -41,8 +42,32 @@ module Rubocop
           check(node)
         end
 
+        def on_send(node)
+          receiver, method_name, *args = *node
+          if visibility_and_def_on_same_line?(receiver, method_name, args)
+            expr = node.loc.expression
+            method_def = args.first
+            range = Parser::Source::Range.new(expr.source_buffer,
+                                              expr.begin_pos,
+                                              method_def.loc.keyword.end_pos)
+            check_offset(method_def, range.source,
+                         method_def.loc.keyword.begin_pos - expr.begin_pos)
+            ignore_node(method_def) # Don't check the same `end` again.
+          end
+        end
+
         private
 
+        # Returns true for constructs such as
+        # private def my_method
+        # which are allowed in Ruby 2.1 and later.
+        def visibility_and_def_on_same_line?(receiver, method_name, args)
+          !receiver &&
+            [:public, :protected, :private,
+             :module_function].include?(method_name) &&
+            args.size == 1 && [:def, :defs].include?(args.first.type)
+        end
+
         def check_assignment(node, rhs)
           # If there are method calls chained to the right hand side of the
           # assignment, we let rhs be the receiver of those method calls before
@@ -55,7 +80,7 @@ module Rubocop
           when :if, :while, :until
             return if rhs.loc.respond_to?(:question) # ternary
 
-            offset = if alignment == :variable
+            offset = if style == :variable
                        rhs.loc.keyword.column - node.loc.expression.column
                      else
                        0
@@ -85,16 +110,16 @@ module Rubocop
               kw_loc.column != end_loc.column + offset
             add_offence(nil, end_loc,
                         sprintf(MSG, end_loc.line, end_loc.column,
-                                alignment_base, kw_loc.line, kw_loc.column))
+                                alignment_base, kw_loc.line, kw_loc.column)) do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
           end
         end
 
-        def alignment
-          a = cop_config['AlignWith']
-          case a
-          when 'keyword', 'variable' then a.to_sym
-          else fail "Unknown AlignWith: #{a}"
-          end
+        def parameter_name
+          'AlignWith'
         end
       end
     end

data/lib/rubocop/cop/lint/invalid_character_literal.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for invalid character literals with a non-escaped
+      # whitespace character (e.g. `? `).
+      # However, currently it's unclear whether there's a way to emit this
+      # warning without syntax errors.
+      #
+      #     $ ruby -w
+      #     p(? )
+      #     -:1: warning: invalid character syntax; use ?\s
+      #     -:1: syntax error, unexpected '?', expecting ')'
+      #     p(? )
+      #        ^
+      #
+      # @example
+      #   p(? )
+      class InvalidCharacterLiteral < Cop
+        include ParserDiagnostic
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :invalid_escape_use
+        end
+
+        def alternative_message(diagnostic)
+          diagnostic.message
+            .capitalize
+            .gsub('character syntax', 'character literal')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -14,10 +14,8 @@ module Rubocop
 
         def on_send(node)
           _receiver, method_name, args = *node
-          if OPERATOR_METHODS.include?(method_name) ||
-              method_name.to_s.end_with?('=')
-            return
-          end
+          return if operator?(method_name) || method_name.to_s.end_with?('=')
+
           if args && args.loc.expression.source.start_with?('(')
             space_length = spaces_before_left_parenthesis(node)
             if space_length > 0

data/lib/rubocop/cop/lint/syntax.rb

@@ -3,11 +3,11 @@
 module Rubocop
   module Cop
     module Lint
-      # This cop actually inspects nothing, just repacks Parser's diagnostics
-      # into RuboCop's offences.
-      # The purpose of this cop is to support disabling Syntax offences with
-      # config or inline comments by conforming to the cop framework.
-      class Syntax < Cop
+      # This is actually not a cop and inspects nothing. It just provides
+      # methods to repack Parser's diagnostics into RuboCop's offences.
+      module Syntax
+        COP_NAME = 'Syntax'.freeze
+
         def self.offences_from_diagnostics(diagnostics)
           diagnostics.map do |diagnostic|
             offence_from_diagnostic(diagnostic)
@@ -19,15 +19,9 @@ module Rubocop
             diagnostic.level,
             diagnostic.location,
             diagnostic.message,
-            cop_name
+            COP_NAME
           )
         end
-
-        def investigate(processed_source)
-          processed_source.diagnostics.each do |d|
-            add_offence(nil, d.location, d.message, d.level)
-          end
-        end
       end
     end
   end