rubocop 0.18.1 → 0.19.0

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

@@ -16,7 +16,7 @@ module Rubocop
         # We won't check modifier or ternary conditionals.
         return unless node.loc.expression.source =~ /\A(if|unless)\b/
         return unless offending_line(node)
-        add_offence(node, :expression, error_message(node))
+        add_offense(node, :expression, error_message(node))
       end
     end
   end

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

@@ -15,7 +15,7 @@ module Rubocop
         if condition.type == :send
           _object, method = *condition
           if method == :! && !(node.loc.respond_to?(:else) && node.loc.else)
-            add_offence(node, :expression, error_message)
+            add_offense(node, :expression, error_message)
           end
         end
       end

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

@@ -9,7 +9,7 @@ module Rubocop
     #       diagnostic.reason == :my_interested_diagnostic_type
     #     end
     #
-    # If you want to use an alternative offence message rather than the one in
+    # If you want to use an alternative offense message rather than the one in
     # Parser's diagnostic, define `#alternative_message`.
     #
     #     def alternative_message(diagnostic)
@@ -26,7 +26,7 @@ module Rubocop
                       d.message.capitalize
                     end
 
-          add_offence(nil, d.location, message, d.level)
+          add_offense(nil, d.location, message, d.level)
         end
       end
     end

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

@@ -10,8 +10,9 @@ module Rubocop
       def investigate(processed_source)
         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)
-            add_offence(t1, t1.pos, sprintf(MSG, kind(t1)))
+              t2.pos.column == t1.pos.column + offset(t1) &&
+              t2.type != :tRPAREN
+            add_offense(t1, t1.pos, format(MSG, kind(t1)))
           end
         end
       end

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

@@ -17,7 +17,7 @@ module Rubocop
               range = Parser::Source::Range.new(processed_source.buffer,
                                                 t1.pos.end_pos,
                                                 t2.pos.begin_pos)
-              add_offence(range, range, format(MSG, kind))
+              add_offense(range, range, format(MSG, kind))
             end
           end
         end

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

@@ -34,6 +34,7 @@ module Rubocop
       end
 
       def max_line_length
+        cop_config && cop_config['MaxLineLength'] ||
         config.for_cop('LineLength')['Max']
       end
 

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

@@ -3,8 +3,8 @@
 module Rubocop
   module Cop
     # Classes that include this module just implement functions to determine
-    # what is an offence and how to do auto-correction. They get help with
-    # adding offences for the faulty string nodes, and with filtering out
+    # what is an offense and how to do auto-correction. They get help with
+    # adding offenses for the faulty string nodes, and with filtering out
     # nodes.
     module StringHelp
       def on_str(node)
@@ -13,8 +13,8 @@ module Rubocop
         return unless node.loc.respond_to?(:begin) && node.loc.begin
         return if part_of_ignored_node?(node)
 
-        if offence?(node)
-          add_offence(node, :expression) { opposite_style_detected }
+        if offense?(node)
+          add_offense(node, :expression) { opposite_style_detected }
         else
           correct_style_detected
         end

data/lib/rubocop/cop/{offence.rb → offense.rb}

@@ -2,8 +2,8 @@
 
 module Rubocop
   module Cop
-    # An Offence represents a style violation detected by RuboCop.
-    class Offence
+    # An offense represents a style violation detected by RuboCop.
+    class Offense
       include Comparable
 
       # @api private
@@ -57,7 +57,7 @@ module Rubocop
       # @!attribute [r] corrected
       #
       # @return [Boolean]
-      #   whether this offence is automatically corrected.
+      #   whether this offense is automatically corrected.
       attr_reader :corrected
       alias_method :corrected?, :corrected
 
@@ -85,8 +85,8 @@ module Rubocop
       # @api private
       # This is just for debugging purpose.
       def to_s
-        sprintf('%s:%3d:%3d: %s',
-                severity_code, line, real_column, message)
+        format('%s:%3d:%3d: %s',
+               severity_code, line, real_column, message)
       end
 
       # @api private
@@ -111,7 +111,7 @@ module Rubocop
       # @api public
       #
       # @return [Boolean]
-      #   returns `true` if two offences contain same attributes
+      #   returns `true` if two offenses contain same attributes
       def ==(other)
         severity == other.severity && line == other.line &&
           column == other.column && message == other.message &&
@@ -121,7 +121,7 @@ module Rubocop
       # @api public
       #
       # Returns `-1`, `0` or `+1`
-      # if this offence is less than, equal to, or greater than `other`.
+      # if this offense is less than, equal to, or greater than `other`.
       #
       # @return [Integer]
       #   comparison result

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

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Rails
+      # This cop enforces the consistent use of action filters methods.
+      #
+      # The cop is configurable and the enforce the use of older
+      # something_filter methods or the newer something_action methods.
+      class ActionFilter < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer %s over %s.'
+
+        FILTER_METHODS = [:before_filter, :skip_before_filter,
+                          :after_filter, :around_filter]
+
+        ACTION_METHODS = [:before_action, :skip_before_action,
+                          :after_action, :around_action]
+
+        def on_block(node)
+          method, _args, _body = *node
+
+          check_method_node(method)
+        end
+
+        def on_send(node)
+          receiver, _method_name, *_args = *node
+
+          check_method_node(node) if receiver.nil?
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              preferred_method(node.loc.selector.source).to_s)
+          end
+        end
+
+        private
+
+        def check_method_node(node)
+          _receiver, method_name, *_args = *node
+
+          if offending_method?(method_name)
+            add_offense(
+              node, :selector,
+              format(MSG,
+                     preferred_method(method_name),
+                     method_name)
+            )
+          end
+        end
+
+        def offending_method?(method_name)
+          bad_methods.include?(method_name)
+        end
+
+        def bad_methods
+          style == :action ? FILTER_METHODS : ACTION_METHODS
+        end
+
+        def good_methods
+          style == :action ? ACTION_METHODS : FILTER_METHODS
+        end
+
+        def preferred_method(method)
+          good_methods[bad_methods.index(method.to_sym)]
+        end
+      end
+    end
+  end
+end

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

@@ -26,7 +26,7 @@ module Rubocop
           first_arg = args[0]
 
           if first_arg.type != :block || lambda_or_proc?(first_arg)
-            add_offence(first_arg, :expression)
+            add_offense(first_arg, :expression)
           end
         end
       end

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

@@ -9,7 +9,7 @@ module Rubocop
 
         def on_send(node)
           if command?(:has_and_belongs_to_many, node)
-            add_offence(node, :selector)
+            add_offense(node, :selector)
           end
         end
       end

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

@@ -14,21 +14,12 @@ module Rubocop
                      :pretty_print]
 
         def on_send(node)
-          return if matches_blacklist?(processed_source)
           receiver, method_name, *_args = *node
 
           if receiver.nil? && BLACKLIST.include?(method_name)
-            add_offence(node, :selector)
+            add_offense(node, :selector)
           end
         end
-
-        def matches_blacklist?(source)
-          ignore_paths.any? { |regex| source.buffer.name =~ /#{regex}/ }
-        end
-
-        def ignore_paths
-          cop_config['Ignore']
-        end
       end
     end
   end

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

@@ -19,7 +19,7 @@ module Rubocop
           receiver, method_name, *_args = *node
 
           if receiver.nil? && method_name == :read_attribute
-            add_offence(node, :selector)
+            add_offense(node, :selector)
           end
         end
       end

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Rails
+      # This cop checks for scope calls where it was passed
+      # a method (usually a scope) instead of a lambda/proc.
+      #
+      # @example
+      #
+      #   # bad
+      #   scope :something, where(something: true)
+      #
+      #   # good
+      #   scope :something, -> { where(something: true) }
+      class ScopeArgs < Cop
+        MSG = 'Use lambda/proc instead of a plain method call.'
+
+        def on_send(node)
+          return unless command?(:scope, node)
+
+          _receiver, _method_name, *args = *node
+
+          return unless args.size == 2
+
+          second_arg = args[1]
+
+          add_offense(second_arg, :expression) if second_arg.type == :send
+        end
+      end
+    end
+  end
+end

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

@@ -22,7 +22,7 @@ module Rubocop
           receiver, method_name, *_args = *node
 
           if receiver.nil? && BLACKLIST.include?(method_name)
-            add_offence(node, :selector)
+            add_offense(node, :selector)
           end
         end
       end

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

@@ -58,7 +58,7 @@ module Rubocop
           if @column_delta == 0
             correct_style_detected
           else
-            add_offence(send_node, :expression) do
+            add_offense(send_node, :expression) do
               if offset == unexpected_indent_offset
                 opposite_style_detected
               else

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

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

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

@@ -13,7 +13,7 @@ module Rubocop
           _receiver, method_name = *method
 
           # using alias is the only option in certain scenarios
-          # in such scenarios we don't want to report an offence
+          # in such scenarios we don't want to report an offense
           if method_name == :instance_exec
             on_node(:alias, body) { |n| ignore_node(n) }
           end
@@ -27,7 +27,7 @@ module Rubocop
 
           return if new.type == :gvar && old.type == :gvar
 
-          add_offence(node, :keyword)
+          add_offense(node, :keyword)
         end
 
         def autocorrect(node)

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

@@ -9,7 +9,7 @@ module Rubocop
         include AutocorrectAlignment
 
         MSG = 'Align the elements of an array literal if they span more ' \
-          'than one line.'
+              'than one line.'
 
         def on_array(node)
           check_alignment(node.children)

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

@@ -6,6 +6,8 @@ module Rubocop
       # Here we check if the keys, separators, and values of a multi-line hash
       # literal are aligned.
       class AlignHash < Cop
+        include IgnoredNode
+
         # Handles calculation of deltas (deviations from correct alignment)
         # when the enforced style is 'key'.
         class KeyAlignment
@@ -144,7 +146,15 @@ module Rubocop
         MSG = 'Align the elements of a hash literal if they span more than ' \
               'one line.'
 
+        def on_send(node)
+          if (last_child = node.children.last) && hash?(last_child) &&
+              ignore_last_argument_hash?(last_child)
+            ignore_node(last_child)
+          end
+        end
+
         def on_hash(node)
+          return if ignored_node?(node)
           return if node.children.empty?
           return unless multiline?(node)
 
@@ -161,17 +171,34 @@ module Rubocop
 
           @column_deltas = alignment_for(first_pair)
             .deltas_for_first_pair(first_pair, node)
-          add_offence(first_pair, :expression) unless good_alignment?
+          add_offense(first_pair, :expression) unless good_alignment?
 
           node.children.each_cons(2) do |prev, current|
             @column_deltas = alignment_for(current).deltas(first_pair, prev,
                                                            current)
-            add_offence(current, :expression) unless good_alignment?
+            add_offense(current, :expression) unless good_alignment?
           end
         end
 
         private
 
+        def ignore_last_argument_hash?(node)
+          case cop_config['EnforcedLastArgumentHashStyle']
+          when 'always_inspect'  then false
+          when 'always_ignore'   then true
+          when 'ignore_explicit' then explicit_hash?(node)
+          when 'ignore_implicit' then !explicit_hash?(node)
+          end
+        end
+
+        def hash?(node)
+          node.respond_to?(:type) && node.type == :hash
+        end
+
+        def explicit_hash?(node)
+          !node.loc.begin.nil?
+        end
+
         def multiline?(node)
           node.loc.expression.source.include?("\n")
         end

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

@@ -9,7 +9,7 @@ module Rubocop
         include AutocorrectAlignment
 
         MSG = 'Align the parameters of a method call if they span ' \
-          'more than one line.'
+              'more than one line.'
 
         def on_send(node)
           _receiver, method, *args = *node
@@ -17,7 +17,21 @@ module Rubocop
           return if method == :[]=
           return if args.size <= 1
 
-          check_alignment(args)
+          check_alignment(args, base_column(node, args))
+        end
+
+        private
+
+        def fixed_indentation?
+          cop_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def base_column(node, args)
+          if fixed_indentation?
+            node.loc.column + 2
+          else
+            args.first.loc.column
+          end
         end
       end
     end