rubocop 0.8.3 → 0.9.0

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

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for literals used as operands in and/or
+      # expressions in the conditions of if/while/until.
+      class LiteralInCondition < Cop
+        MSG = 'Literal %s appeared in a condition.'
+
+        LITERALS = [:str, :dstr, :int, :float, :array,
+                    :hash, :regexp, :nil, :true, :false]
+
+        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
+
+        def check_for_literal(node)
+          cond, = *node
+
+          on_node([:and, :or], cond) do |logic_node|
+            *operands = *logic_node
+            operands.each do |op|
+              if LITERALS.include?(op.type)
+                add_offence(:warning, op.loc.expression,
+                            format(MSG, op.loc.expression.source))
+
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for uses of *begin...end while/until something*.
+      class Loop < Cop
+        MSG = 'Use Kernel#loop with break rather than ' +
+              'begin/end/until(or while).'
+
+        def on_while_post(node)
+          register_offence(node)
+          super
+        end
+
+        def on_until_post(node)
+          register_offence(node)
+          super
+        end
+
+        private
+
+        def register_offence(node)
+          add_offence(:warning, node.loc.keyword, MSG)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for *rescue* blocks targeting the Exception class.
+      class RescueException < Cop
+        MSG = 'Avoid rescuing the Exception class.'
+
+        def on_resbody(node)
+          return unless node.children.first
+          rescue_args = node.children.first.children
+          if rescue_args.any? { |a| targets_exception?(a) }
+            add_offence(:warning, node.location.expression, MSG)
+          end
+
+          super
+        end
+
+        def targets_exception?(rescue_arg_node)
+          return false unless rescue_arg_node.type == :const
+          namespace, klass_name = *rescue_arg_node
+          return false unless namespace.nil? || namespace.type == :cbase
+          klass_name == :Exception
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop looks for use of the same name as outer local variables
+      # for block arguments or block local variables.
+      # This is a mimic of the warning
+      # "shadowing outer local variable - foo" from `ruby -cw`.
+      class ShadowingOuterLocalVariable < Cop
+        include VariableInspector
+
+        MSG = 'Shadowing outer local variable - %s'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          inspect_variables(ast)
+        end
+
+        def before_declaring_variable(entry)
+          # Only block scope can reference outer local variables.
+          return unless variable_table.current_scope.node.type == :block
+          return unless ARGUMENT_DECLARATION_TYPES.include?(entry.node.type)
+
+          outer_local_variable = variable_table.find_variable_entry(entry.name)
+          return unless outer_local_variable
+
+          message = sprintf(MSG, entry.name)
+          add_offence(:warning, entry.node.loc.expression, message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for unreachable code.
+      # The check are based on the presence of flow of control
+      # statement in non-final position in *begin*(implicit) blocks.
+      class UnreachableCode < Cop
+        MSG = 'Unreachable code detected.'
+
+        NODE_TYPES = [:return, :next, :break, :retry, :redo]
+        FLOW_COMMANDS = [:throw, :raise, :fail]
+
+        def on_begin(node)
+          expressions = *node
+
+          expressions.each_cons(2) do |e1, e2|
+            if NODE_TYPES.include?(e1.type) || flow_command?(e1)
+              add_offence(:warning, e2.loc.expression, MSG)
+            end
+          end
+
+          super
+        end
+
+        private
+
+        def flow_command?(node)
+          FLOW_COMMANDS.any? { |c| command?(c, node) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop looks for unused local variables in each scope.
+      # Actually this is a mimic of the warning
+      # "assigned but unused variable - foo" from `ruby -cw`.
+      class UnusedLocalVariable < Cop
+        include VariableInspector
+
+        MSG = 'Assigned but unused variable - %s'
+        TYPES_TO_ACCEPT_UNUSED =
+          (ARGUMENT_DECLARATION_TYPES - [:shadowarg]).freeze
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          inspect_variables(ast)
+        end
+
+        def after_leaving_scope(scope)
+          scope.variable_entries.each_value do |entry|
+            next if entry.used?
+            next if TYPES_TO_ACCEPT_UNUSED.include?(entry.node.type)
+            next if entry.name.to_s.start_with?('_')
+            message = sprintf(MSG, entry.name)
+            add_offence(:warning, entry.node.loc.expression, message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for operators, variables and literals used
+      # in void context.
+      class Void < Cop
+        OP_MSG = 'Operator %s used in void context.'
+        VAR_MSG = 'Variable %s used in void context.'
+        LIT_MSG = 'Literal %s used in void context'
+
+        OPS = %w(* / % + - == === != < > <= >= <=>)
+        VARS = [:ivar, :lvar, :cvar, :const]
+        LITERALS = [:str, :dstr, :int, :float, :array,
+                    :hash, :regexp, :nil, :true, :false]
+
+        def on_begin(node)
+          expressions = *node
+
+          expressions[0...-1].each do |expr|
+            check_for_void_op(expr)
+            check_for_literal(expr)
+            check_for_var(expr)
+          end
+
+          super
+        end
+
+        private
+
+        def check_for_void_op(node)
+          return unless node.type == :send
+
+          op = node.loc.selector.source
+
+          if OPS.include?(op)
+            add_offence(:warning, node.loc.selector, sprintf(OP_MSG, op))
+          end
+        end
+
+        def check_for_var(node)
+          if VARS.include?(node.type)
+            add_offence(:warning, node.loc.name,
+                        sprintf(VAR_MSG, node.loc.name.source))
+          end
+        end
+
+        def check_for_literal(node)
+          if LITERALS.include?(node.type)
+            add_offence(:warning, node.loc.expression,
+                        sprintf(LIT_MSG, node.loc.expression.source))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/offence.rb

@@ -2,34 +2,134 @@
 
 module Rubocop
   module Cop
+    # An Offence represents a style violation detected by RuboCop.
     class Offence
-      attr_accessor :severity, :line_number, :message
+      include Comparable
 
+      # @api private
       SEVERITIES = [:refactor, :convention, :warning, :error, :fatal]
 
-      def initialize(severity, line_number, message)
-        @severity = severity
-        @line_number = line_number
-        @message = message
+      # @api public
+      #
+      # @!attribute [r] severity
+      #
+      # @return [Symbol]
+      #   severity.
+      #   any of `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
+      attr_reader :severity
+
+      # @api public
+      #
+      # @!attribute [r] location
+      #
+      # @return [Parser::Source::Range]
+      #   the location where the violation is detected.
+      #
+      # @see http://rubydoc.info/github/whitequark/parser/Parser/Source/Range
+      #   Parser::Source::Range
+      attr_reader :location
+
+      # @api public
+      #
+      # @!attribute [r] message
+      #
+      # @return [String]
+      #   human-readable message
+      #
+      # @example
+      #   'Line is too long. [90/79]'
+      attr_reader :message
+
+      # @api public
+      #
+      # @!attribute [r] cop_name
+      #
+      # @return [String]
+      #   a cop class name without namespace.
+      #   i.e. type of the violation.
+      #
+      # @example
+      #   'LineLength'
+      attr_reader :cop_name
+
+      # @api private
+      attr_reader :line
+
+      # @api private
+      attr_reader :column
+
+      # @api private
+      def initialize(severity, location, message, cop_name)
+        unless SEVERITIES.include?(severity)
+          fail ArgumentError, "Unknown severity: #{severity}"
+        end
+        @severity = severity.freeze
+        @location = location.freeze
+        @line = location.line.freeze
+        @column = location.column.freeze
+        @message = message.freeze
+        @cop_name = cop_name.freeze
+        freeze
       end
 
+      # @api private
       def to_s
-        # we must be wary of messages containing % in them
-        sprintf("#{encode_severity}:%3d: #{message.gsub(/%/, '%%')}",
-                line_number)
+        sprintf("#{encode_severity}:%3d:%3d: %s",
+                line, real_column, message)
       end
 
+      # @api private
       def encode_severity
         @severity.to_s[0].upcase
       end
 
+      # @api private
+      def clang_severity
+        case @severity
+        when :fatal then 'F'.color(:red)
+        when :error then 'E'.color(:red)
+        when :warning then 'W'.color(:magenta)
+        when :convention then 'C'.color(:yellow)
+        end
+      end
+
+      # @api private
+      def severity_level
+        SEVERITIES.index(severity) + 1
+      end
+
+      # @api private
+      #
+      # Internally we use column number that start at 0, but when
+      # outputting column numbers, we want them to start at 1. One
+      # reason is that editors, such as Emacs, expect this.
+      def real_column
+        column + 1
+      end
+
+      # @api public
+      #
+      # @return [Boolean]
+      #   returns `true` if two offences contain same attributes
       def ==(other)
-        severity == other.severity && line_number == other.line_number &&
-          message == other.message
+        severity == other.severity && line == other.line &&
+          column == other.column && message == other.message &&
+          cop_name == other.cop_name
       end
 
-      def explode
-        [severity, line_number, message]
+      # @api public
+      #
+      # Returns `-1`, `0` or `+1`
+      # if this offence is less than, equal to, or greater than `other`.
+      #
+      # @return [Integer]
+      #   comparison result
+      def <=>(other)
+        [:line, :column, :cop_name, :message].each do |attribute|
+          result = send(attribute) <=> other.send(attribute)
+          return result unless result == 0
+        end
+        0
       end
     end
   end

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Rails
+      # This cop checks for the use of old-style attribute validation macros.
+      class Validation < Cop
+        MSG = 'Use the new "sexy" validations (validates ...).'
+
+        BLACKLIST = [:validates_acceptance_of,
+                     :validates_confirmation_of,
+                     :validates_exclusion_of,
+                     :validates_format_of,
+                     :validates_inclusion_of,
+                     :validates_length_of,
+                     :validates_numericality_of,
+                     :validates_presence_of,
+                     :validates_size_of]
+
+        def self.rails?
+          true
+        end
+
+        def on_send(node)
+          receiver, method_name, *_args = *node
+
+          if receiver.nil? && BLACKLIST.include?(method_name)
+            add_offence(:convention, node.loc.selector, MSG)
+          end
+        end
+      end
+    end
+  end
+end