rubocop 0.9.1 → 0.10.0

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for empty `ensure` blocks
+      class EmptyEnsure < Cop
+        MSG = 'Empty ensure block detected.'
+
+        def on_ensure(node)
+          _body, ensure_body = *node
+
+          add_offence(:warning, node.loc.keyword, MSG) unless ensure_body
+        end
+      end
+    end
+  end
+end

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

@@ -7,160 +7,44 @@ module Rubocop
       #
       # For keywords (if, def, etc.) the end is aligned with the start
       # of the keyword.
-      # For blocks - with the start of the expression where the block
-      # is defined.
       #
       # @example
       #
       #   variable = if true
       #              end
-      #
-      #   variable = lambda do |i|
-      #     i
-      #   end
       class EndAlignment < Cop
         MSG = 'end at %d, %d is not aligned with %s at %d, %d'
 
-        def initialize
-          super
-          @inspected_blocks = []
-        end
-
-        def inspect(source_buffer, source, tokens, ast, comments)
-          @inspected_blocks = []
-          super
-        end
-
         def on_def(node)
           check(node)
-          super
         end
 
         def on_defs(node)
           check(node)
-          super
         end
 
         def on_class(node)
           check(node)
-          super
         end
 
         def on_module(node)
           check(node)
-          super
         end
 
         def on_if(node)
           check(node) if node.loc.respond_to?(:end)
-          super
         end
 
         def on_while(node)
           check(node)
-          super
         end
 
         def on_until(node)
           check(node)
-          super
-        end
-
-        # Block related alignments
-
-        def on_block(node)
-          return if already_processed_node?(node)
-          check_block_alignment(node.loc.expression, node.loc)
-          super
-        end
-
-        def on_and(node)
-          return if already_processed_node?(node)
-
-          _left, right = *node
-          if right.type == :block
-            check_block_alignment(node.loc.expression, right.loc)
-            @inspected_blocks << right
-          end
-          super
-        end
-
-        alias_method :on_or, :on_and
-
-        def on_lvasgn(node)
-          _, children = *node
-          process_block_assignment(node, children)
-          super
-        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)
-          super
-        end
-
-        def on_op_asgn(node)
-          variable, _op, args = *node
-          process_block_assignment(variable, args)
-          super
-        end
-
-        def on_send(node)
-          _receiver, _method, *args = *node
-          process_block_assignment(node, args.last)
-          super
-        end
-
-        def on_masgn(node)
-          variables, args = *node
-          process_block_assignment(variables, args)
-          super
         end
 
         private
 
-        def process_block_assignment(begin_node, block_node)
-          return unless block_node
-          return if already_processed_node?(block_node)
-
-          while block_node.type == :send
-            receiver, _method, args = *block_node
-            if receiver && [:block, :send].include?(receiver.type)
-              block_node = receiver
-            elsif args && [:block, :send].include?(args.type)
-              block_node = args
-            else
-              break
-            end
-          end
-          if block_node.type == :block
-            # Align with the expression that is on the same line
-            # where the block is defined
-            return if block_is_on_next_line?(begin_node, block_node)
-
-            @inspected_blocks << block_node
-            check_block_alignment(begin_node.loc.expression, block_node.loc)
-          end
-        end
-
-        def check_block_alignment(start_loc, block_loc)
-          end_loc = block_loc.end
-          if block_loc.begin.line != end_loc.line &&
-               start_loc.column != end_loc.column
-            add_offence(:warning,
-                        end_loc,
-                        sprintf(MSG, end_loc.line, end_loc.column,
-                                start_loc.source.lines.to_a.first.chomp,
-                                start_loc.line, start_loc.column))
-          end
-        end
-
         def check(node)
           # discard modifier forms of if/while/until
           return unless node.loc.end
@@ -175,14 +59,6 @@ module Rubocop
                                 kw_loc.source, kw_loc.line, kw_loc.column))
           end
         end
-
-        def already_processed_node?(node)
-          @inspected_blocks.include?(node)
-        end
-
-        def block_is_on_next_line?(begin_node, block_node)
-          begin_node.loc.line != block_node.loc.line
-        end
       end
     end
   end

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

@@ -9,12 +9,10 @@ module Rubocop
 
         def on_def(node)
           check(node)
-          super
         end
 
         def on_defs(node)
           check(node)
-          super
         end
 
         private

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

@@ -10,11 +10,11 @@ module Rubocop
         def on_ensure(node)
           _body, ensure_body = *node
 
+          return unless ensure_body
+
           on_node(:return, ensure_body) do |e|
             add_offence(:warning, e.loc.expression, MSG)
-          end if ensure_body
-
-          super
+          end
         end
       end
     end

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

@@ -13,8 +13,6 @@ module Rubocop
           if receiver.nil? && method_name == :eval
             add_offence(:warning, node.loc.selector, MSG)
           end
-
-          super
         end
       end
     end

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

@@ -11,8 +11,6 @@ module Rubocop
           _exc_list_node, _exc_var_node, body_node = *node
 
           add_offence(:warning, node.loc.expression, MSG) unless body_node
-
-          super
         end
       end
     end

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

@@ -25,32 +25,22 @@ module Rubocop
 
         def on_if(node)
           check_for_literal(node)
-
-          super
         end
 
         def on_while(node)
           check_for_literal(node)
-
-          super
         end
 
         def on_while_post(node)
           check_for_literal(node)
-
-          super
         end
 
         def on_until(node)
           check_for_literal(node)
-
-          super
         end
 
         def on_until_post(node)
           check_for_literal(node)
-
-          super
         end
 
         private

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

@@ -10,12 +10,10 @@ module Rubocop
 
         def on_while_post(node)
           register_offence(node)
-          super
         end
 
         def on_until_post(node)
           register_offence(node)
-          super
         end
 
         private

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

@@ -13,8 +13,6 @@ module Rubocop
           if rescue_args.any? { |a| targets_exception?(a) }
             add_offence(:warning, node.location.expression, MSG)
           end
-
-          super
         end
 
         def targets_exception?(rescue_arg_node)

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

@@ -12,8 +12,8 @@ module Rubocop
 
         MSG = 'Shadowing outer local variable - %s'
 
-        def inspect(source_buffer, source, tokens, ast, comments)
-          inspect_variables(ast)
+        def investigate(processed_source)
+          inspect_variables(processed_source.ast)
         end
 
         def before_declaring_variable(entry)

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

@@ -20,8 +20,6 @@ module Rubocop
               add_offence(:warning, e2.loc.expression, MSG)
             end
           end
-
-          super
         end
 
         private

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

@@ -13,8 +13,8 @@ module Rubocop
         TYPES_TO_ACCEPT_UNUSED =
           (ARGUMENT_DECLARATION_TYPES - [:shadowarg]).freeze
 
-        def inspect(source_buffer, source, tokens, ast, comments)
-          inspect_variables(ast)
+        def investigate(processed_source)
+          inspect_variables(processed_source.ast)
         end
 
         def after_leaving_scope(scope)

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

@@ -23,8 +23,6 @@ module Rubocop
             check_for_literal(expr)
             check_for_var(expr)
           end
-
-          super
         end
 
         private

data/lib/rubocop/cop/offence.rb

@@ -9,6 +9,15 @@ module Rubocop
       # @api private
       SEVERITIES = [:refactor, :convention, :warning, :error, :fatal]
 
+      def self.from_diagnostic(diagnostic)
+        new(
+          diagnostic.level,
+          diagnostic.location,
+          diagnostic.message,
+          'Syntax'
+        )
+      end
+
       # @api public
       #
       # @!attribute [r] severity

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

@@ -15,7 +15,8 @@ module Rubocop
                      :validates_length_of,
                      :validates_numericality_of,
                      :validates_presence_of,
-                     :validates_size_of]
+                     :validates_size_of,
+                     :validates_uniqueness_of]
 
         def on_send(node)
           receiver, method_name, *_args = *node

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

@@ -14,7 +14,8 @@ module Rubocop
         PROTECTED_NODE = s(:send, nil, :protected)
         PUBLIC_NODE = s(:send, nil, :public)
 
-        def inspect(source_buffer, source, tokens, ast, comments)
+        def investigate(processed_source)
+          ast = processed_source.ast
           return unless ast
           on_node([:class, :module, :sclass], ast) do |class_node|
             class_start_col = class_node.loc.expression.column
@@ -35,8 +36,8 @@ module Rubocop
 
                   send_line = send_node.loc.line
 
-                  unless source[send_line].chomp.empty? &&
-                      source[send_line - 2].chomp.empty?
+                  unless processed_source[send_line].chomp.empty? &&
+                      processed_source[send_line - 2].chomp.empty?
                     add_offence(:convention,
                                 send_node.loc.expression,
                                 format(BLANK_MSG, selector))

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

@@ -8,8 +8,8 @@ module Rubocop
       class Alias < Cop
         MSG = 'Use alias_method instead of alias.'
 
-        # TODO make this check context aware - alias_method is not
-        # available outside of classes/modules.
+        # TODO: Make this check context aware - alias_method is not
+        #   available outside of classes/modules.
         def on_alias(node)
           # alias_method can't be used with global variables
           new, old = *node
@@ -19,8 +19,6 @@ module Rubocop
           add_offence(:convention,
                       node.loc.keyword,
                       MSG)
-
-          super
         end
       end
     end

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

@@ -30,8 +30,6 @@ module Rubocop
               prev_arg_line = cur_arg_line
             end
           end
-
-          super
         end
       end
     end

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

@@ -11,14 +11,10 @@ module Rubocop
 
         def on_and(node)
           process_logical_op(node)
-
-          super
         end
 
         def on_or(node)
           process_logical_op(node)
-
-          super
         end
 
         private
@@ -36,8 +32,10 @@ module Rubocop
         end
 
         def autocorrect_action(node)
-          replacement = (node.type == :and ? '&&' : '||')
-          replace(node.loc.operator, replacement)
+          @corrections << lambda do |corrector|
+            replacement = (node.type == :and ? '&&' : '||')
+            corrector.replace(node.loc.operator, replacement)
+          end
         end
       end
     end