rubocop 0.23.0 → 0.24.0

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking for space before
+    # punctuation.
+    module SpaceBeforePunctuation
+      MSG = 'Space found before %s.'
+
+      def investigate(processed_source)
+        processed_source.tokens.each_cons(2) do |t1, t2|
+          next unless kind(t2) && t1.pos.line == t2.pos.line &&
+            t2.pos.begin_pos > t1.pos.end_pos
+          buffer = processed_source.buffer
+          pos_before_punctuation = Parser::Source::Range.new(buffer,
+                                                             t1.pos.end_pos,
+                                                             t2.pos.begin_pos)
+
+          add_offense(pos_before_punctuation,
+                      pos_before_punctuation,
+                      format(MSG, kind(t2)))
+        end
+      end
+
+      def autocorrect(pos_before_punctuation)
+        @corrections << lambda do |corrector|
+          corrector.remove(pos_before_punctuation)
+        end
+      end
+    end
+  end
+end

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

@@ -5,14 +5,13 @@ module RuboCop
     # Common functionality for checking surrounding space.
     module SurroundingSpace
       def space_between?(t1, t2)
-        char_preceding_2nd_token =
-          @processed_source[t2.pos.line - 1][t2.pos.column - 1]
-        if char_preceding_2nd_token == '+' && t1.type != :tPLUS
-          # Special case. A unary plus is not present in the tokens.
-          char_preceding_2nd_token =
-            @processed_source[t2.pos.line - 1][t2.pos.column - 2]
-        end
-        t2.pos.line > t1.pos.line || char_preceding_2nd_token =~ /[ \t]/
+        between = Parser::Source::Range.new(t1.pos.source_buffer,
+                                            t1.pos.end_pos,
+                                            t2.pos.begin_pos).source
+        # Check if the range between the tokens starts with a space. It can
+        # contain other characters, e.g. a unary plus, but it must start with
+        # space.
+        between =~ /^\s/
       end
 
       def index_of_first_token(node)

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

@@ -23,7 +23,7 @@ module RuboCop
         end
 
         def check_argument(variable)
-          return if variable.name.to_s.start_with?('_')
+          return if variable.should_be_unused?
           return if variable.referenced?
 
           message = message(variable)

data/lib/rubocop/cop/offense.rb

@@ -6,6 +6,9 @@ module RuboCop
     class Offense
       include Comparable
 
+      # @api private
+      COMPARISON_ATTRIBUTES = [:line, :column, :cop_name, :message, :severity]
+
       # @api public
       #
       # @!attribute [r] severity
@@ -56,21 +59,13 @@ module RuboCop
       attr_reader :corrected
       alias_method :corrected?, :corrected
 
-      # @api private
-      attr_reader :line
-
-      # @api private
-      attr_reader :column
-
       # @api private
       def initialize(severity, location, message, cop_name, corrected = false)
         @severity = RuboCop::Cop::Severity.new(severity)
-        @location = location.freeze
-        @line = location.line.freeze
-        @column = location.column.freeze
+        @location = location
         @message = message.freeze
         @cop_name = cop_name.freeze
-        @corrected = corrected.freeze
+        @corrected = corrected
         freeze
       end
 
@@ -81,6 +76,16 @@ module RuboCop
                severity.code, line, real_column, message)
       end
 
+      # @api private
+      def line
+        location.line
+      end
+
+      # @api private
+      def column
+        location.column
+      end
+
       # @api private
       #
       # Internally we use column number that start at 0, but when
@@ -95,9 +100,17 @@ module RuboCop
       # @return [Boolean]
       #   returns `true` if two offenses contain same attributes
       def ==(other)
-        severity == other.severity && line == other.line &&
-          column == other.column && message == other.message &&
-          cop_name == other.cop_name
+        COMPARISON_ATTRIBUTES.all? do |attribute|
+          send(attribute) == other.send(attribute)
+        end
+      end
+
+      alias_method :eql?, :==
+
+      def hash
+        COMPARISON_ATTRIBUTES.reduce(0) do |hash, attribute|
+          hash ^ send(attribute).hash
+        end
       end
 
       # @api public
@@ -108,7 +121,7 @@ module RuboCop
       # @return [Integer]
       #   comparison result
       def <=>(other)
-        [:line, :column, :cop_name, :message].each do |attribute|
+        COMPARISON_ATTRIBUTES.each do |attribute|
           result = send(attribute) <=> other.send(attribute)
           return result unless result == 0
         end

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

@@ -8,13 +8,10 @@ module RuboCop
       class AccessModifierIndentation < Cop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
+        include AccessModifierNode
 
         MSG = '%s access modifiers like `%s`.'
 
-        PRIVATE_NODE = s(:send, nil, :private)
-        PROTECTED_NODE = s(:send, nil, :protected)
-        PUBLIC_NODE = s(:send, nil, :public)
-
         def on_class(node)
           _name, _base_class, body = *node
           check_body(body, node)
@@ -35,16 +32,12 @@ module RuboCop
           check_body(body, node) if class_constructor?(node)
         end
 
-        def self.modifier_node?(node)
-          [PRIVATE_NODE, PROTECTED_NODE, PUBLIC_NODE].include?(node)
-        end
-
         private
 
         def check_body(body, node)
           return if body.nil? # Empty class etc.
 
-          modifiers = body.children.select { |c| self.class.modifier_node?(c) }
+          modifiers = body.children.select { |c| modifier_node?(c) }
           class_column = node.loc.expression.column
 
           modifiers.each { |modifier| check_modifier(modifier, class_column) }

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

@@ -8,7 +8,9 @@ module RuboCop
         MSG = 'Do not use `attr`. Use `attr_reader` instead.'
 
         def on_send(node)
-          add_offense(node, :selector) if command?(:attr, node)
+          return unless command?(:attr, node)
+          _receiver, _method_name, *args = *node
+          add_offense(node, :selector) if args.any?
         end
 
         def autocorrect(node)

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces consistent use of `Object#is_a?` or `Object#kind_of?`.
+      class ClassCheck < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `Object#%s` over `Object#%s`.'
+
+        def on_send(node)
+          _receiver, method_name, *_args = *node
+          return unless [:is_a?,
+                         :kind_of?].include?(method_name)
+
+          return if style == method_name
+          add_offense(node, :selector)
+        end
+
+        def message(node)
+          _receiver, method_name, *_args = *node
+
+          if method_name == :is_a?
+            format(MSG, 'kind_of?', 'is_a?')
+          else
+            format(MSG, 'is_a?', 'kind_of?')
+          end
+        end
+
+        def autocorrect(node)
+          _receiver, method_name, *_args = *node
+
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              method_name == :is_a? ? 'kind_of?' : 'is_a?')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -19,10 +19,14 @@ module RuboCop
 
         def on_block(node)
           method, args, body = *node
+
+          # filter out super and zsuper nodes
+          return unless method.type == :send
+
           _, method_name, method_args = *method
 
           return unless METHODS.include? method_name
-          return if method_args.type == :sym
+          return if method_args && method_args.type == :sym
 
           return_value = return_value(body)
           return unless return_value

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

@@ -26,10 +26,7 @@ module RuboCop
                 next unless processed_source[line - 2].empty? &&
                   processed_source[line - 1].empty?
 
-                range = source_range(processed_source.buffer,
-                                     processed_source[0...(line - 1)],
-                                     0,
-                                     1)
+                range = source_range(processed_source.buffer, line, 0)
                 add_offense(range, range)
               end
             end

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

@@ -5,11 +5,9 @@ module RuboCop
     module Style
       # Access modifiers should be surrounded by blank lines.
       class EmptyLinesAroundAccessModifier < Cop
-        MSG = 'Keep a blank line before and after `%s`.'
+        include AccessModifierNode
 
-        PRIVATE_NODE = s(:send, nil, :private)
-        PROTECTED_NODE = s(:send, nil, :protected)
-        PUBLIC_NODE = s(:send, nil, :public)
+        MSG = 'Keep a blank line before and after `%s`.'
 
         def on_send(node)
           return unless modifier_node?(node)
@@ -38,10 +36,6 @@ module RuboCop
         def message(node)
           format(MSG, node.loc.selector.source)
         end
-
-        def modifier_node?(node)
-          [PRIVATE_NODE, PROTECTED_NODE, PUBLIC_NODE].include?(node)
-        end
       end
     end
   end

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

@@ -62,10 +62,7 @@ module RuboCop
         def check_line(line, msg)
           return unless processed_source.lines[line].empty?
 
-          range = source_range(processed_source.buffer,
-                               processed_source[0...line],
-                               0,
-                               1)
+          range = source_range(processed_source.buffer, line + 1, 0)
           add_offense(range, range, msg)
         end
       end

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

@@ -24,11 +24,9 @@ module RuboCop
           message = offense(processed_source, line_number)
 
           return unless message
-          add_offense(nil,
-                      source_range(processed_source.buffer,
-                                   processed_source[0...line_number],
-                                   0, 1),
-                      message)
+
+          range = source_range(processed_source.buffer, line_number + 1, 0)
+          add_offense(nil, range, message)
         end
 
         private

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

@@ -15,11 +15,8 @@ module RuboCop
           original_source.lines.each_with_index do |line, index|
             next unless line =~ /\r$/
 
-            add_offense(nil,
-                        source_range(buffer,
-                                     processed_source[0...index],
-                                     0, line.length),
-                        MSG)
+            range = source_range(buffer, index + 1, 0, line.length)
+            add_offense(nil, range, MSG)
             # Usually there will be carriage return characters on all or none
             # of the lines in a file, so we report only one offense.
             break

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

@@ -16,10 +16,8 @@ module RuboCop
           basename = File.basename(file_path).sub(/\.[^\.]+$/, '')
           return if snake_case?(basename)
 
-          add_offense(nil,
-                      source_range(processed_source.buffer,
-                                   processed_source[0..0],
-                                   0, 1))
+          range = source_range(processed_source.buffer, 1, 0)
+          add_offense(nil, range)
         end
 
         private

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

@@ -8,7 +8,8 @@ module RuboCop
         include IfThenElse
 
         def offending_line(node)
-          node.loc.begin.line if node.loc.begin && node.loc.begin.is?(';')
+          b = node.loc.begin
+          b.line if b && b.is?(';')
         end
 
         def error_message(_node)

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

@@ -15,6 +15,7 @@ module RuboCop
       # end
       class IndentationConsistency < Cop
         include AutocorrectAlignment
+        include AccessModifierNode
 
         MSG = 'Inconsistent indentation detected.'
 
@@ -32,7 +33,7 @@ module RuboCop
           children_to_check = node.children.reject do |child|
             # Don't check nodes that have special indentation and will be
             # checked by the AccessModifierIndentation cop.
-            AccessModifierIndentation.modifier_node?(child)
+            modifier_node?(child)
           end
 
           check_alignment(children_to_check)

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

@@ -12,15 +12,33 @@ module RuboCop
       #   puts 'hello'
       #  end
       # end
-      class IndentationWidth < Cop
+      class IndentationWidth < Cop # rubocop:disable Style/ClassLength
         include AutocorrectAlignment
         include CheckMethods
         include CheckAssignment
         include IfNode
+        include AccessModifierNode
 
         CORRECT_INDENTATION = 2
 
+        def on_rescue(node)
+          _begin_node, *rescue_nodes, else_node = *node
+          rescue_nodes.each do |rescue_node|
+            _, _, body = *rescue_node
+            check_indentation(rescue_node.loc.keyword, body)
+          end
+          check_indentation(node.loc.else, else_node)
+        end
+
+        def on_ensure(node)
+          _body, ensure_body = *node
+          check_indentation(node.loc.keyword, ensure_body)
+        end
+
         def on_kwbegin(node)
+          # Check indentation against end keyword but only if it's first on its
+          # line.
+          return unless begins_its_line?(node.loc.end)
           check_indentation(node.loc.end, node.children.first)
         end
 
@@ -78,7 +96,7 @@ module RuboCop
           latest_when = nil
           branches.compact.each do |b|
             if b.type == :when
-              _condition, body = *b
+              *_conditions, body = *b
               # Check "when" body against "when" keyword indentation.
               check_indentation(b.loc.keyword, body)
               latest_when = b
@@ -164,7 +182,10 @@ module RuboCop
 
           # This cop only auto-corrects the first statement in a def body, for
           # example.
-          body_node = body_node.children.first if body_node.type == :begin
+          if body_node.type == :begin && !(body_node.loc.begin &&
+                                           body_node.loc.begin.is?('('))
+            body_node = body_node.children.first
+          end
 
           expr = body_node.loc.expression
           begin_pos, ind = expr.begin_pos, expr.begin_pos - indentation
@@ -177,8 +198,7 @@ module RuboCop
         end
 
         def starts_with_access_modifier?(body_node)
-          body_node.type == :begin &&
-            AccessModifierIndentation.modifier_node?(body_node.children.first)
+          body_node.type == :begin && modifier_node?(body_node.children.first)
         end
       end
     end

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

@@ -1,5 +1,7 @@
 # encoding: utf-8
 
+require 'uri'
+
 module RuboCop
   module Cop
     module Style
@@ -14,12 +16,24 @@ module RuboCop
           processed_source.lines.each_with_index do |line, index|
             next unless line.length > max
 
+            if allow_uri?
+              uri_range = find_excessive_uri_range(line)
+              next if uri_range && allowed_uri_position?(line, uri_range)
+            end
+
             message = format(MSG, line.length, max)
-            add_offense(nil,
-                        source_range(processed_source.buffer,
-                                     processed_source[0...index], max,
-                                     line.length - max),
-                        message) do
+
+            excessive_position = if uri_range && uri_range.begin < max
+                                   uri_range.end
+                                 else
+                                   max
+                                 end
+
+            range = source_range(processed_source.buffer,
+                                 index + 1,
+                                 excessive_position...(line.length))
+
+            add_offense(nil, range, message) do
               self.max = line.length
             end
           end
@@ -28,6 +42,46 @@ module RuboCop
         def max
           cop_config['Max']
         end
+
+        def allow_uri?
+          cop_config['AllowURI']
+        end
+
+        def allowed_uri_position?(line, uri_range)
+          uri_range.begin < max && uri_range.end == line.length
+        end
+
+        def find_excessive_uri_range(line)
+          last_uri_match = match_uris(line).last
+          return nil unless last_uri_match
+          begin_position, end_position = last_uri_match.offset(0)
+          return nil if begin_position < max && end_position < max
+          begin_position...end_position
+        end
+
+        def match_uris(string)
+          matches = []
+          unscanned_position = 0
+
+          loop do
+            match_data = string.match(URI.regexp, unscanned_position)
+            break unless match_data
+
+            uri_ish_string = match_data[0]
+            matches << match_data if valid_uri?(uri_ish_string)
+
+            _, unscanned_position = match_data.offset(0)
+          end
+
+          matches
+        end
+
+        def valid_uri?(uri_ish_string)
+          URI.parse(uri_ish_string)
+          true
+        rescue URI::InvalidURIError
+          false
+        end
       end
     end
   end