rubocop 0.8.3 → 0.9.0

data/lib/rubocop/config_store.rb

@@ -1,6 +1,8 @@
 # encoding: utf-8
 
 module Rubocop
+  # Handles chaching of configurations and association of inspected
+  # ruby files to configurations.
   module ConfigStore
     module_function
 

data/lib/rubocop/cop/cop.rb

@@ -2,6 +2,7 @@
 
 module Rubocop
   module Cop
+    # A basic wrapper around Parser's tokens.
     class Token
       attr_reader :pos, :type, :text
 
@@ -14,11 +15,17 @@ module Rubocop
       end
     end
 
-    class Cop < Parser::AST::Processor
+    # A scaffold for concrete cops.
+    #
+    # The Cop class is meant to be extended.
+    #
+    # Cops track offences and can autocorrect them of the fly.
+    class Cop < Parser::Rewriter
       extend AST::Sexp
 
       attr_accessor :offences
       attr_accessor :debug
+      attr_accessor :autocorrect
       attr_writer :disabled_lines
 
       @all = []
@@ -37,26 +44,44 @@ module Rubocop
         name.to_s.split('::').last
       end
 
+      def self.rails?
+        false
+      end
+
       def initialize
         @offences = []
         @debug = false
+        @autocorrect = false
+      end
+
+      def inspect(source_buffer, source, tokens, ast, comments)
+        if autocorrect
+          filename = source_buffer.instance_variable_get(:@name)
+          new_source = rewrite(source_buffer, ast)
+          unless new_source == source_buffer.source
+            File.open(filename, 'w') { |f| f.write(new_source) }
+            source_buffer.instance_variable_set(:@source, nil)
+            source_buffer.read
+          end
+        else
+          process(ast)
+        end
       end
 
-      def has_report?
-        !@offences.empty?
+      def do_autocorrect(node)
+        autocorrect_action(node) if autocorrect
       end
 
-      def inspect(source, tokens, ast, comments)
-        process(ast)
+      def autocorrect_action(node)
       end
 
       def ignore_node(node)
       end
 
-      def add_offence(severity, line_number, message)
-        unless @disabled_lines && @disabled_lines.include?(line_number)
+      def add_offence(severity, location, message)
+        unless @disabled_lines && @disabled_lines.include?(location.line)
           message = debug ? "#{name}: #{message}" : message
-          @offences << Offence.new(severity, line_number, message)
+          @offences << Offence.new(severity, location, message, name)
         end
       end
 
@@ -77,6 +102,25 @@ module Rubocop
           end
         end
       end
+
+      def command?(name, node)
+        return unless node.type == :send
+
+        receiver, method_name, _args = *node
+
+        # commands have no explicit receiver
+        !receiver && method_name == name
+      end
+
+      def source_range(source_buffer, preceding_lines, begin_column,
+                       column_count)
+        newline_length = 1
+        begin_pos = preceding_lines.reduce(0) do |a, e|
+                      a + e.length + newline_length
+                    end + begin_column
+        Parser::Source::Range.new(source_buffer, begin_pos,
+                                  begin_pos + column_count)
+      end
     end
   end
 end

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

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for assignments in the conditions of
+      # if/while/until.
+      class AssignmentInCondition < Cop
+        ASGN_NODES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn]
+        MSG = 'Assignment in condition - you probably meant to use ==.'
+
+        def on_if(node)
+          check(node)
+          super
+        end
+
+        def on_while(node)
+          check(node)
+          super
+        end
+
+        def on_until(node)
+          check(node)
+          super
+        end
+
+        private
+
+        def check(node)
+          condition, = *node
+
+          on_node([:begin, *ASGN_NODES], condition) do |asgn_node|
+            # skip safe assignment nodes if safe assignment is allowed
+            return if safe_assignment_allowed? && safe_assignment?(asgn_node)
+
+            # assignment nodes from shorthand ops like ||= don't have operator
+            if asgn_node.type != :begin && asgn_node.loc.operator
+              add_offence(:warning, asgn_node.loc.operator, MSG)
+            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?
+          AssignmentInCondition.config['AllowSafeAssignment']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks whether the end keywords are aligned properly.
+      #
+      # There are two ways to align the end of a block.
+      # Set BlockAlignSchema to StartOfAssignment if you want to
+      # align the end to the beginning of assignment expression.
+      # This is the default behavior.
+      # @example
+      #
+      #   variable = lambda do |i|
+      #     i
+      #   end
+      #
+      # Set BlockAlignSchema to StartOfBlockCommand if you want to
+      # align the end to the beginning of the expression that called the block.
+      # @example
+      #
+      #   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_lvasgn(node)
+          if align_with_start_of_assignment?
+            _, children = *node
+            process_block_assignment(node, children)
+          end
+          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)
+          if align_with_start_of_assignment?
+            _, _, children = *node
+            process_block_assignment(node, children)
+          end
+          super
+        end
+
+        def on_op_asgn(node)
+          if align_with_start_of_assignment?
+            variable, _op, args = *node
+            process_block_assignment(variable, args)
+          end
+          super
+        end
+
+        def on_send(node)
+          if align_with_start_of_assignment?
+            receiver, method, args = *node
+            if attribute_writer?(method)
+              process_block_assignment(receiver, args)
+            end
+          end
+          super
+        end
+
+        def on_masgn(node)
+          if align_with_start_of_assignment?
+            variables, args = *node
+            process_block_assignment(variables, args)
+          end
+          super
+        end
+
+        private
+
+        def process_block_assignment(begin_node, block_node)
+          if block_node && block_node.type == :block
+            @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
+
+          kw_loc = node.loc.keyword
+          end_loc = node.loc.end
+
+          if kw_loc.line != end_loc.line && kw_loc.column != end_loc.column
+            add_offence(:warning,
+                        end_loc,
+                        sprintf(MSG, end_loc.line, end_loc.column,
+                                kw_loc.source, kw_loc.line, kw_loc.column))
+          end
+        end
+
+        def already_processed_node?(node)
+          @inspected_blocks.include?(node)
+        end
+
+        def attribute_writer?(method)
+          method.to_s[-1] == '='
+        end
+
+        def align_with_start_of_assignment?
+          EndAlignment.config['BlockAlignSchema'] == 'StartOfAssignment'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for END blocks in method definitions.
+      class EndInMethod < Cop
+        MSG = 'END found in method definition. Use `at_exit` instead.'
+
+        def on_def(node)
+          check(node)
+          super
+        end
+
+        def on_defs(node)
+          check(node)
+          super
+        end
+
+        private
+
+        def check(node)
+          on_node(:postexe, node) do |end_node|
+            add_offence(:warning, end_node.loc.keyword, MSG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for *return* from an *ensure* block.
+      class EnsureReturn < Cop
+        MSG = 'Never return from an ensure block.'
+
+        def on_ensure(node)
+          _body, ensure_body = *node
+
+          on_node(:return, ensure_body) do |e|
+            add_offence(:warning, e.loc.expression, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for the use of *Kernel#eval*.
+      class Eval < Cop
+        MSG = 'The use of eval is a serious security risk.'
+
+        def on_send(node)
+          receiver, method_name, = *node
+
+          if receiver.nil? && method_name == :eval
+            add_offence(:warning, node.loc.selector, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for *rescue* blocks with no body.
+      class HandleExceptions < Cop
+        MSG = 'Do not suppress exceptions.'
+
+        def on_resbody(node)
+          _exc_list_node, _exc_var_node, body_node = *node
+
+          add_offence(:warning, node.loc.expression, MSG) unless body_node
+
+          super
+        end
+      end
+    end
+  end
+end