rubocop 0.18.1 → 0.19.0

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

@@ -13,8 +13,9 @@ module Rubocop
 
           prev_line = 1
 
-          processed_source.tokens.each do |token|
+          processed_source.tokens.sort_by { |t| t.pos.line }.each do |token|
             cur_line = token.pos.line
+
             line_diff = cur_line - prev_line
 
             if line_diff > LINE_OFFSET
@@ -28,7 +29,7 @@ module Rubocop
                                        processed_source[0...(line - 1)],
                                        0,
                                        1)
-                  add_offence(range, range)
+                  add_offense(range, range)
                 end
               end
             end

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

@@ -16,7 +16,7 @@ module Rubocop
 
           return if empty_lines_around?(node)
 
-          add_offence(node, :expression)
+          add_offense(node, :expression)
         end
 
         private

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

@@ -65,7 +65,7 @@ module Rubocop
                                  processed_source[0...line],
                                  0,
                                  1)
-            add_offence(range, range, msg)
+            add_offense(range, range, msg)
           end
         end
       end

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

@@ -33,11 +33,11 @@ module Rubocop
 
           case node
           when ARRAY_NODE
-            add_offence(node, :expression, ARR_MSG)
+            add_offense(node, :expression, ARR_MSG)
           when HASH_NODE
-            add_offence(node, :expression, HASH_MSG)
+            add_offense(node, :expression, HASH_MSG)
           when STR_NODE
-            add_offence(node, :expression, STR_MSG)
+            add_offense(node, :expression, STR_MSG)
           end
         end
 

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

@@ -16,7 +16,7 @@ module Rubocop
             line_number += 1 if processed_source[line_number] =~ /^#!/
             line = processed_source[line_number]
             unless line =~ /#.*coding\s?[:=]\s?(UTF|utf)-8/
-              add_offence(nil,
+              add_offense(nil,
                           source_range(processed_source.buffer,
                                        processed_source[0...line_number],
                                        0, 1),

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

@@ -8,7 +8,7 @@ module Rubocop
         MSG = 'Avoid the use of END blocks. Use `Kernel#at_exit` instead.'
 
         def on_postexe(node)
-          add_offence(node, :keyword)
+          add_offense(node, :keyword)
         end
       end
     end

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

@@ -13,13 +13,13 @@ module Rubocop
                                     encoding: buffer.source.encoding)
           original_source.lines.each_with_index do |line, index|
             if line =~ /\r$/
-              add_offence(nil,
+              add_offense(nil,
                           source_range(buffer,
                                        processed_source[0...index],
                                        0, line.length),
                           MSG)
               # Usually there will be carriage return characters on all or none
-              # of the lines in a file, so we report only one offence.
+              # of the lines in a file, so we report only one offense.
               break
             end
           end

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

@@ -28,11 +28,11 @@ module Rubocop
           return unless div_by_2?(receiver)
 
           if args == ZERO
-            add_offence(node,
+            add_offense(node,
                         :expression,
                         method == :== ? MSG_EVEN : MSG_ODD)
           elsif args == ONE
-            add_offence(node,
+            add_offense(node,
                         :expression,
                         method == :== ? MSG_ODD : MSG_EVEN)
           end

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

@@ -16,7 +16,7 @@ module Rubocop
 
           if receiver_node && receiver_node.type == :array &&
               method_name == :* && arg_nodes[0].type == :str
-            add_offence(node, :selector)
+            add_offense(node, :selector)
           end
         end
       end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop makes sure that Ruby source files have snake_case names.
+      class FileName < Cop
+        MSG = 'Use snake_case for source file names.'
+
+        SNAKE_CASE = /^[\da-z_]+$/
+
+        def investigate(processed_source)
+          file_path = processed_source.buffer.name
+
+          return if config.file_to_include?(file_path)
+
+          basename = File.basename(file_path).sub(/\.[^\.]+$/, '')
+
+          unless basename =~ SNAKE_CASE
+            add_offense(nil,
+                        source_range(processed_source.buffer,
+                                     processed_source[0..0],
+                                     0, 1))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -14,7 +14,7 @@ module Rubocop
             range = source_range(processed_source.buffer,
                                  processed_source[0...-1],
                                  final_line.length - 1, 1)
-            add_offence(range, range)
+            add_offense(range, range)
           end
         end
 

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

@@ -8,11 +8,11 @@ module Rubocop
         MSG = 'Avoid the use of flip flop operators.'
 
         def on_iflipflop(node)
-          add_offence(node, :expression)
+          add_offense(node, :expression)
         end
 
         def on_eflipflop(node)
-          add_offence(node, :expression)
+          add_offense(node, :expression)
         end
       end
     end

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

@@ -12,7 +12,7 @@ module Rubocop
 
         def on_for(node)
           if style == :each
-            add_offence(node, :keyword, 'Prefer *each* over *for*.') do
+            add_offense(node, :keyword, 'Prefer *each* over *for*.') do
               opposite_style_detected
             end
           else
@@ -34,7 +34,7 @@ module Rubocop
             range = Parser::Source::Range.new(processed_source.buffer,
                                               end_pos - 'each'.length,
                                               end_pos)
-            add_offence(range, range, 'Prefer *for* over *each*.') do
+            add_offense(range, range, 'Prefer *for* over *each*.') do
               opposite_style_detected
             end
           else

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

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop enforces the use of a single string formatting utility.
+      # Valid options include Kernel#format, Kernel#sprintf and String#%.
+      #
+      # The detection of String#% cannot be implemented in a reliable
+      # manner for all cases, so only two scenarios are considered -
+      # if the first argument is a string literal and if the second
+      # argument is an array literal.
+      class FormatString < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_send(node)
+          add_offense(node, :selector) if offending_node?(node)
+        end
+
+        private
+
+        def offending_node?(node)
+          case style
+          when :format
+            sprintf?(node) || percent?(node)
+          when :sprintf
+            format?(node) || percent?(node)
+          when :percent
+            format?(node) || sprintf?(node)
+          end
+        end
+
+        def format?(node)
+          command?(:format, node)
+        end
+
+        def sprintf?(node)
+          command?(:sprintf, node)
+        end
+
+        def percent?(node)
+          receiver_node, method_name, *arg_nodes = *node
+
+          method_name == :% &&
+            ([:str, :dstr].include?(receiver_node.type) ||
+             arg_nodes[0].type == :array)
+        end
+
+        def message(node)
+          _receiver_node, method_name, *_arg_nodes = *node
+
+          preferred =
+            if style == :percent
+              'String#%'
+            else
+              style
+            end
+
+          method_name = 'String#%' if method_name == :%
+
+          "Favor #{preferred} over #{method_name}."
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Rubocop
   module Cop
     module Style
       # This cops looks for uses of global variables.
-      # It does not report offences for built-in global variables.
+      # It does not report offenses for built-in global variables.
       # Built-in global variables are allowed by default. Additionally
       # users can allow additional variables via the AllowedVariables option.
       #
@@ -66,7 +66,7 @@ module Rubocop
         def check(node)
           global_var, = *node
 
-          add_offence(node, :name) unless allowed_var?(global_var)
+          add_offense(node, :name) unless allowed_var?(global_var)
         end
       end
     end

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

@@ -14,7 +14,7 @@ module Rubocop
           _receiver, method_name, *args = *node
 
           if args.size == 1 && DEPRECATED_METHODS.include?(method_name)
-            add_offence(node, :selector,
+            add_offense(node, :selector,
                         MSG.format(method_name,
                                    proper_method_name(method_name)))
           end

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

@@ -8,7 +8,7 @@ module Rubocop
       # It can enforce either the use of the class hash rocket syntax or
       # the use of the newer Ruby 1.9 syntax (when applicable).
       #
-      # A separate offence is registered for each problematic pair.
+      # A separate offense is registered for each problematic pair.
       class HashSyntax < Cop
         include ConfigurableEnforcedStyle
 
@@ -41,7 +41,7 @@ module Rubocop
             # Don't do the correction if there is no space before '=>'. The
             # combined corrections of this cop and SpaceAroundOperators could
             # produce code with illegal syntax.
-            fail CorrectionNotPossible
+            return
           end
 
           @corrections << lambda do |corrector|
@@ -65,7 +65,7 @@ module Rubocop
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.loc.operator && pair.loc.operator.is?(delim)
-              add_offence(pair,
+              add_offense(pair,
                           pair.loc.expression.begin.join(pair.loc.operator),
                           msg) do
                 opposite_style_detected

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

@@ -5,6 +5,7 @@ module Rubocop
     module Style
       # Checks for if and unless statements that would fit on one line
       # if written as a modifier if/unless.
+      # The maximum line length is configurable.
       class IfUnlessModifier < Cop
         include StatementModifier
 
@@ -23,7 +24,7 @@ module Rubocop
             next if if_else?(node)
 
             if check(node, processed_source.comments)
-              add_offence(node, :keyword,
+              add_offense(node, :keyword,
                           error_message(node.loc.keyword.source))
             end
           end

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

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops checks the indentation of the first element in an array
+      # literal where the opening bracket and the first element are on separate
+      # lines. The other elements' indentations are handled by the AlignArray
+      # cop.
+      #
+      # Array literals shall have their first element indented one step (2
+      # spaces) more than the start of the line where the opening bracket is.
+      class IndentArray < Cop
+        include AutocorrectAlignment
+
+        def on_array(node)
+          first_pair = node.children.first
+          return if first_pair.nil?
+
+          left_bracket = node.loc.begin
+          return if left_bracket.nil?
+
+          return if first_pair.loc.expression.line == left_bracket.line
+
+          column = first_pair.loc.expression.column
+          base_column = left_bracket.source_line =~ /\S/
+          expected_column = base_column + IndentationWidth::CORRECT_INDENTATION
+          @column_delta = expected_column - column
+
+          add_offense(first_pair, :expression) if @column_delta != 0
+        end
+
+        def message(_)
+          format('Use %d spaces for indentation in an array, relative to ' \
+                 'the start of the line where the left bracket is.',
+                 IndentationWidth::CORRECT_INDENTATION)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops checks the indentation of the first key in a hash literal
+      # where the opening brace and the first key are on separate lines. The
+      # other keys' indentations are handled by the AlignHash cop.
+      #
+      # Hash literals that are arguments in a method call with parentheses, and
+      # where the opening curly brace of the hash is on the same line as the
+      # opening parenthesis of the method call, shall have their first key
+      # indented one step (two spaces) more than the position inside the
+      # opening parenthesis.
+      #
+      # Other hash literals shall have their first key indented one step more
+      # than the start of the line where the opening curly brace is.
+      class IndentHash < Cop
+        include AutocorrectAlignment
+        include ConfigurableEnforcedStyle
+
+        def on_hash(node)
+          left_brace = node.loc.begin
+          check(node, left_brace, nil) if left_brace
+        end
+
+        def on_send(node)
+          _receiver, _method_name, *args = *node
+          left_parenthesis = node.loc.begin
+          return unless left_parenthesis
+
+          args.each do |arg|
+            on_node(:hash, arg, :send) do |hash_node|
+              left_brace = hash_node.loc.begin
+              if left_brace && left_brace.line == left_parenthesis.line
+                check(hash_node, left_brace, left_parenthesis)
+                ignore_node(hash_node)
+              end
+            end
+          end
+        end
+
+        private
+
+        def check(hash_node, left_brace, left_parenthesis)
+          return if ignored_node?(hash_node)
+
+          first_pair = hash_node.children.first
+          return if first_pair.nil?
+
+          left_brace = hash_node.loc.begin
+          return if first_pair.loc.expression.line == left_brace.line
+
+          column = first_pair.loc.expression.column
+          @column_delta =
+            expected_column(left_brace, left_parenthesis) - column
+
+          if @column_delta == 0
+            correct_style_detected
+          else
+            add_offense(first_pair, :expression,
+                        message(base_description(left_parenthesis))) do
+              if column == unexpected_column(left_brace, left_parenthesis)
+                opposite_style_detected
+              else
+                unrecognized_style_detected
+              end
+            end
+          end
+        end
+
+        # Returns the expected, or correct indentation.
+        def expected_column(left_brace, left_parenthesis)
+          base_column =
+            if left_parenthesis && style == :special_inside_parentheses
+              left_parenthesis.column + 1
+            else
+              left_brace.source_line =~ /\S/
+            end
+
+          base_column + IndentationWidth::CORRECT_INDENTATION
+        end
+
+        # Returns the description of what the correct indentation is based on.
+        def base_description(left_parenthesis)
+          if left_parenthesis && style == :special_inside_parentheses
+            'the first position after the preceding left parenthesis'
+          else
+            'the start of the line where the left curly brace is'
+          end
+        end
+
+        # Returns the "unexpected column", which is the column that would be
+        # correct if the configuration was changed.
+        def unexpected_column(left_brace, left_parenthesis)
+          # Set a crazy value by default, indicating that there's no other
+          # configuration that can be chosen to make the used indentation
+          # accepted.
+          unexpected_base_column = -1000
+
+          if left_parenthesis
+            unexpected_base_column = if style == :special_inside_parentheses
+                                       left_brace.source_line =~ /\S/
+                                     else
+                                       left_parenthesis.column + 1
+                                     end
+          end
+
+          unexpected_base_column + IndentationWidth::CORRECT_INDENTATION
+        end
+
+        def message(base_description)
+          format('Use %d spaces for indentation in a hash, relative to %s.',
+                 IndentationWidth::CORRECT_INDENTATION, base_description)
+        end
+      end
+    end
+  end
+end