rubocop 0.19.1 → 0.20.0

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

@@ -5,8 +5,8 @@ module Rubocop
     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).'
+        MSG = 'Use `Kernel#loop` with `break` rather than ' \
+              '`begin/end/until`(or `while`).'
 
         def on_while_post(node)
           register_offense(node)

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

@@ -59,10 +59,6 @@ module Rubocop
           method_name =~ /\w\?$/
         end
 
-        def parentheses?(node)
-          node.loc.respond_to?(:end) && node.loc.end
-        end
-
         def offense?(node)
           [:and, :or].include?(node.type)
         end

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

@@ -5,7 +5,7 @@ module Rubocop
     module Lint
       # This cop checks for *rescue* blocks targeting the Exception class.
       class RescueException < Cop
-        MSG = 'Avoid rescuing the Exception class.'
+        MSG = 'Avoid rescuing the `Exception` class.'
 
         def on_resbody(node)
           return unless node.children.first

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

@@ -10,7 +10,7 @@ module Rubocop
       class ShadowingOuterLocalVariable < Cop
         include VariableInspector
 
-        MSG = 'Shadowing outer local variable - %s'
+        MSG = 'Shadowing outer local variable - `%s`'
 
         def investigate(processed_source)
           inspect_variables(processed_source.ast)

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

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # Checks for space between a method name and the first argument for
+      # method calls without parentheses.
+      #
+      # @example
+      #
+      #   something?x
+      #   something!x
+      #
+      class SpaceBeforeFirstArg < Cop
+        MSG = 'Put space between the method name and the first argument.'
+
+        def on_send(node)
+          return if parentheses?(node)
+
+          _receiver, method_name, *args = *node
+          return if args.empty?
+          return if operator?(method_name)
+
+          # Setter calls with parentheses are parsed this way. The parentheses
+          # belong to the argument, not the send node.
+          return if args.first.type == :begin
+
+          arg1 = args.first.loc.expression
+          arg1_with_space = range_with_surrounding_space(arg1, :left)
+
+          add_offense(nil, arg1) if arg1_with_space.source =~ /^\S/
+        end
+      end
+    end
+  end
+end

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

@@ -10,12 +10,12 @@ module Rubocop
       #
       #   "result is #{something.to_s}"
       class StringConversionInInterpolation < Cop
-        MSG = 'Redundant use of Object#to_s in interpolation.'
+        MSG = 'Redundant use of `Object#to_s` in interpolation.'
 
         def on_dstr(node)
           node.children.select { |n| n.type == :begin }.each do |begin_node|
             final_node = begin_node.children.last
-            next unless final_node.type == :send
+            next unless final_node && final_node.type == :send
 
             _receiver, method_name, *args = *final_node
 
@@ -24,6 +24,18 @@ module Rubocop
             end
           end
         end
+
+        private
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            receiver, _method_name, *_args = *node
+            corrector.replace(
+              node.loc.expression,
+              receiver.loc.expression.source
+            )
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for access modifiers without any code.
+      #
+      # @example
+      #   class Foo
+      #     private # This is useless
+      #
+      #     def self.some_method
+      #     end
+      #   end
+      class UselessAccessModifier < Cop
+        MSG = 'Useless `%s` access modifier.'
+
+        def on_class(node)
+          _name, _base_class, body = *node
+          return unless body
+
+          body_nodes = body.type == :begin ? body.children : [body]
+
+          body_nodes.each do |child_node|
+            check_for_access_modifier(child_node)
+            check_for_instance_method(child_node)
+          end
+
+          add_offense_for_access_modifier
+        end
+
+        private
+
+        def add_offense_for_access_modifier
+          return unless @access_modifier_node
+
+          _, modifier = *@access_modifier_node
+          message = format(MSG, modifier)
+          add_offense(@access_modifier_node, :expression, message)
+        end
+
+        def check_for_instance_method(node)
+          return unless node.type == :def
+
+          @access_modifier_node = nil
+        end
+
+        def check_for_access_modifier(node)
+          return unless Style::AccessModifierIndentation
+            .modifier_node?(node)
+
+          add_offense_for_access_modifier
+          @access_modifier_node = node
+        end
+      end
+    end
+  end
+end

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

@@ -40,7 +40,7 @@ module Rubocop
 
           add_offense(receiver,
                       :name,
-                      MSG.format(receiver.loc.name.source))
+                      format(MSG, receiver.loc.name.source))
         end
 
         def setter_call_to_local_variable?(node)

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

@@ -6,9 +6,9 @@ module Rubocop
       # 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'
+        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]

data/lib/rubocop/cop/mixin/space_after_punctuation.rb

@@ -11,7 +11,7 @@ module Rubocop
         processed_source.tokens.each_cons(2) do |t1, t2|
           if kind(t1) && t1.pos.line == t2.pos.line &&
               t2.pos.column == t1.pos.column + offset(t1) &&
-              t2.type != :tRPAREN
+              ![:tRPAREN, :tRBRACK].include?(t2.type)
             add_offense(t1, t1.pos, format(MSG, kind(t1)))
           end
         end

data/lib/rubocop/cop/offense.rb

@@ -6,16 +6,11 @@ module Rubocop
     class Offense
       include Comparable
 
-      # @api private
-      SEVERITIES = [:refactor, :convention, :warning, :error, :fatal]
-
       # @api public
       #
       # @!attribute [r] severity
       #
-      # @return [Symbol]
-      #   severity.
-      #   any of `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
+      # @return [Rubocop::Cop::Severity]
       attr_reader :severity
 
       # @api public
@@ -69,10 +64,7 @@ module Rubocop
 
       # @api private
       def initialize(severity, location, message, cop_name, corrected = false)
-        unless SEVERITIES.include?(severity)
-          fail ArgumentError, "Unknown severity: #{severity}"
-        end
-        @severity = severity.freeze
+        @severity = Rubocop::Cop::Severity.new(severity)
         @location = location.freeze
         @line = location.line.freeze
         @column = location.column.freeze
@@ -86,17 +78,7 @@ module Rubocop
       # This is just for debugging purpose.
       def to_s
         format('%s:%3d:%3d: %s',
-               severity_code, line, real_column, message)
-      end
-
-      # @api private
-      def severity_code
-        @severity.to_s[0].upcase
-      end
-
-      # @api private
-      def severity_level
-        SEVERITIES.index(severity) + 1
+               severity.code, line, real_column, message)
       end
 
       # @api private

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

@@ -10,7 +10,7 @@ module Rubocop
       class ActionFilter < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Prefer %s over %s.'
+        MSG = 'Prefer `%s` over `%s`.'
 
         FILTER_METHODS = [:before_filter, :skip_before_filter,
                           :after_filter, :around_filter]

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

@@ -14,7 +14,7 @@ module Rubocop
       #   # correct
       #   default_scope { something }
       class DefaultScope < Cop
-        MSG = 'default_scope expects a block as its sole argument.'
+        MSG = '`default_scope` expects a block as its sole argument.'
 
         def on_send(node)
           return unless command?(:default_scope, node)

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

@@ -5,7 +5,7 @@ module Rubocop
     module Rails
       # This cop checks for the use of the has_and_belongs_to_many macro.
       class HasAndBelongsToMany < Cop
-        MSG = 'Prefer has_many :through to has_and_belongs_to_many.'
+        MSG = 'Prefer `has_many :through` to `has_and_belongs_to_many`.'
 
         def on_send(node)
           if command?(:has_and_belongs_to_many, node)

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

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Rails
+      # This cop checks for the use of the read_attribute or
+      # write_attribute methods.
+      #
+      # @example
+      #
+      #   # bad
+      #   x = read_attributed(:attr)
+      #   write_attribute(:attr, val)
+      #
+      #   # good
+      #   x = self[:attr]
+      #   self[:attr] = val
+      class ReadWriteAttribute < Cop
+        MSG = 'Prefer `%s` over `%s`.'
+
+        def on_send(node)
+          receiver, method_name, *_args = *node
+
+          return if receiver
+
+          if [:read_attribute, :write_attribute].include?(method_name)
+            add_offense(node, :selector)
+          end
+        end
+
+        def message(node)
+          _receiver, method_name, *_args = *node
+
+          if method_name == :read_attribute
+            format(MSG, 'self[:attr]', 'read_attribute(:attr)')
+          else
+            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, var)')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -14,7 +14,7 @@ module Rubocop
       #   # good
       #   scope :something, -> { where(something: true) }
       class ScopeArgs < Cop
-        MSG = 'Use lambda/proc instead of a plain method call.'
+        MSG = 'Use `lambda`/`proc` instead of a plain method call.'
 
         def on_send(node)
           return unless command?(:scope, node)

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

@@ -5,7 +5,7 @@ module Rubocop
     module Rails
       # This cop checks for the use of old-style attribute validation macros.
       class Validation < Cop
-        MSG = 'Use the new "sexy" validations (validates ...).'
+        MSG = 'Use the new "sexy" validations (`validates` ...).'
 
         BLACKLIST = [:validates_acceptance_of,
                      :validates_confirmation_of,

data/lib/rubocop/cop/severity.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Severity class is simple value object about severity
+    class Severity
+      include Comparable
+
+      # @api private
+      NAMES = [:refactor, :convention, :warning, :error, :fatal]
+
+      # @api private
+      CODE_TABLE = { R: :refactor, C: :convention,
+                     W: :warning, E: :error, F: :fatal }
+
+      # @api public
+      #
+      # @!attribute [r] name
+      #
+      # @return [Symbol]
+      #   severity.
+      #   any of `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
+      attr_reader :name
+
+      # @api private
+      def self.name_from_code(code)
+        name = code.to_sym
+        CODE_TABLE[name] || name
+      end
+
+      # @api private
+      def initialize(name_or_code)
+        name = Severity.name_from_code(name_or_code)
+        unless NAMES.include?(name)
+          fail ArgumentError, "Unknown severity: #{name}"
+        end
+        @name = name.freeze
+        freeze
+      end
+
+      # @api private
+      def to_s
+        @name.to_s
+      end
+
+      # @api private
+      def code
+        @name.to_s[0].upcase
+      end
+
+      # @api private
+      def level
+        NAMES.index(name) + 1
+      end
+
+      # @api private
+      def ==(other)
+        if other.is_a?(Symbol)
+          @name == other
+        else
+          @name == other.name
+        end
+      end
+
+      # @api private
+      def hash
+        @name.hash
+      end
+
+      # @api private
+      def <=>(other)
+        level <=> other.level
+      end
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ module Rubocop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
 
-        MSG = '%s access modifiers like %s.'
+        MSG = '%s access modifiers like `%s`.'
 
         PRIVATE_NODE = s(:send, nil, :private)
         PROTECTED_NODE = s(:send, nil, :protected)

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

@@ -25,10 +25,10 @@ module Rubocop
         def check(node, method_name, args, _body)
           if bad_reader_name?(method_name.to_s, args)
             add_offense(node, :name,
-                        'Do not prefix reader method names with get_.')
+                        'Do not prefix reader method names with `get_`.')
           elsif bad_writer_name?(method_name.to_s, args)
             add_offense(node, :name,
-                        'Do not prefix writer method names with set_.')
+                        'Do not prefix writer method names with `set_`.')
           end
         end