rubocop 0.24.1 → 0.25.0

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

@@ -8,7 +8,11 @@ module RuboCop
         include SpaceInside
 
         def specifics
-          [:tLBRACK, :tRBRACK, 'square brackets']
+          [
+            [:tLBRACK, :tLBRACK2],
+            :tRBRACK,
+            'square brackets'
+          ]
         end
       end
     end

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

@@ -23,14 +23,11 @@ module RuboCop
         def offense?(node)
           src = node.loc.expression.source
           return false if src =~ /^(%[qQ]?|\?|<<-)/i
-          src !~ if style == :single_quotes
-                   # regex matches IF there is a ' or there is a \\ in the
-                   # string that is not preceeded/followed by another \\
-                   # (e.g. "\\x34") but not "\\\\"
-                   /' | (?<! \\) \\{2}* \\ (?! \\)/x
-                 else
-                   /" | \\/x
-                 end
+          if style == :single_quotes
+            src !~ /'/ && src !~ StringHelp::ESCAPED_CHAR_REGEXP
+          else
+            src !~ /" | \\/x
+          end
         end
 
         def autocorrect(node)

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

@@ -121,20 +121,32 @@ module RuboCop
           range = Parser::Source::Range.new(sb, comma_begin_pos,
                                             comma_begin_pos + 1)
           article = kind =~ /array/ ? 'an' : 'a'
-          add_offense(nil, range,
+          add_offense(range, range,
                       format(MSG, 'Avoid', format(kind, article)) +
                       extra_info + '.')
         end
 
         def put_comma(items, kind, sb)
-          last_expr = items.last.loc.expression
+          last_item = items.last
+          return if last_item.type == :block_pass
+
+          last_expr = last_item.loc.expression
           ix = last_expr.source.rindex("\n") || 0
           ix += last_expr.source[ix..-1] =~ /\S/
           range = Parser::Source::Range.new(sb, last_expr.begin_pos + ix,
                                             last_expr.end_pos)
-          add_offense(nil, range,
+          add_offense(range, range,
                       format(MSG, 'Put a', format(kind, 'a multiline') + '.'))
         end
+
+        def autocorrect(range)
+          @corrections << lambda do |corrector|
+            case range.source
+            when ',' then corrector.remove(range)
+            else          corrector.insert_after(range, ',')
+            end
+          end
+        end
       end
     end
   end

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

@@ -6,13 +6,13 @@ module RuboCop
       # This cop looks for trivial reader/writer methods, that could
       # have been created with the attr_* family of functions automatically.
       class TrivialAccessors < Cop
-        include CheckMethods
+        include OnMethod
 
         MSG = 'Use `attr_%s` to define trivial %s methods.'
 
         private
 
-        def check(node, method_name, args, body)
+        def on_method(node, method_name, args, body)
           kind = if trivial_reader?(method_name, args, body)
                    'reader'
                  elsif trivial_writer?(method_name, args, body)

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

@@ -16,10 +16,8 @@ module RuboCop
 
         private
 
-        def on_percent_literal(node, types)
-          type = type(node)
-          return unless types.include?(type) &&
-            node.children.none? { |x| x.type == :dstr }
+        def on_percent_literal(node)
+          return unless node.children.none? { |x| x.type == :dstr }
 
           add_offense(node, :expression)
         end

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

@@ -17,12 +17,25 @@ module RuboCop
           check(node)
         end
 
+        # We process regexp nodes because the inner str nodes can cause
+        # confusion in on_str if they start with %( or %Q(.
+        def on_regexp(node)
+          string_parts = node.children.select { |child| child.type == :str }
+          string_parts.each { |s| ignore_node(s) }
+        end
+
         private
 
         def check(node)
+          if node.loc.respond_to?(:heredoc_body)
+            ignore_node(node)
+            return
+          end
+          return if ignored_node?(node) || part_of_ignored_node?(node)
           src = node.loc.expression.source
           return unless src =~ /^%q/i
           return if src =~ /'/ && src =~ /"/
+          return if src =~ StringHelp::ESCAPED_CHAR_REGEXP
 
           extra = if src =~ /^%Q/
                     ', or for dynamic strings that contain double quotes'

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

@@ -8,6 +8,20 @@ module RuboCop
         MSG = 'Replace interpolated variable `%s` with expression `#{%s}`.'
 
         def on_dstr(node)
+          check_for_interpolation(node)
+        end
+
+        def on_regexp(node)
+          check_for_interpolation(node)
+        end
+
+        def on_xstr(node)
+          check_for_interpolation(node)
+        end
+
+        private
+
+        def check_for_interpolation(node)
           var_nodes(node.children).each do |v|
             var = v.loc.expression.source
 
@@ -15,8 +29,6 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(node)
           @corrections << lambda do |corrector|
             expr = node.loc.expression

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

@@ -9,35 +9,35 @@ module RuboCop
         include ConfigurableNaming
 
         def on_lvasgn(node)
-          check(node, name_of_variable(node))
+          name, = *node
+          check_name(node, name, node.loc.name)
         end
 
         def on_ivasgn(node)
-          check(node, name_of_variable(node))
+          name, = *node
+          check_name(node, name, node.loc.name)
         end
 
+        # TODO: Why is this checking invocations of setter rather than
+        #   definitions? Also, this is not variable.
         def on_send(node)
-          check(node, name_of_setter(node))
+          return unless setter_call_on_self?(node)
+          _receiver, method_name, = *node
+          attribute_name = method_name.to_s.sub(/=$/, '').to_sym
+          check_name(node, attribute_name, node.loc.selector)
         end
 
-        def name_of_variable(vasgn_node)
-          expr = vasgn_node.loc.expression
-          name = vasgn_node.children.first
-          Parser::Source::Range.new(expr.source_buffer, expr.begin_pos,
-                                    expr.begin_pos + name.length)
-        end
-
-        def name_of_setter(send_node)
-          receiver, method_name = *send_node
-          return unless receiver && receiver.type == :self
-          return unless method_name.to_s.end_with?('=')
-          after_dot(send_node, method_name.length - '='.length,
-                    Regexp.escape(receiver.loc.expression.source))
-        end
+        private
 
         def message(style)
           format('Use %s for variables.', style)
         end
+
+        def setter_call_on_self?(send_node)
+          receiver, method_name, = *send_node
+          return false unless receiver && receiver.type == :self
+          method_name.to_s.end_with?('=')
+        end
       end
     end
   end

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

@@ -14,11 +14,8 @@ module RuboCop
           on_node([:while, :until], processed_source.ast) do |node|
             # discard modifier while/until
             next unless node.loc.end
-
-            if check(node, processed_source.comments)
-              add_offense(node, :keyword,
-                          message(node.loc.keyword.source))
-            end
+            next unless fit_within_line_as_modifier_form?(node)
+            add_offense(node, :keyword, message(node.loc.keyword.source))
           end
         end
 

data/lib/rubocop/cop/util.rb

@@ -153,6 +153,11 @@ module RuboCop
         Parser::Source::Range.new(@processed_source.buffer, begin_pos, end_pos)
       end
 
+      def begins_its_line?(range)
+        source_before_end = range.source_buffer.source[0...range.begin_pos]
+        source_before_end =~ /\n\s*\Z/
+      end
+
       # Returns, for example, a bare `if` node if the given node is an `if`
       # with calls chained to the end of it.
       def first_part_of_call_chain(node)

data/lib/rubocop/cop/variable_force.rb

@@ -22,7 +22,7 @@ module RuboCop
     #
     #     def after_declaring_variable(variable, variable_table)
     #     end
-    class VariableForce < Force # rubocop:disable Style/ClassLength
+    class VariableForce < Force # rubocop:disable Metrics/ClassLength
       VARIABLE_ASSIGNMENT_TYPE = :lvasgn
       REGEXP_NAMED_CAPTURE_TYPE = :match_with_lvasgn
       VARIABLE_ASSIGNMENT_TYPES =
@@ -99,7 +99,7 @@ module RuboCop
         throw :skip_children
       end
 
-      # rubocop:disable Style/MethodLength, Style/CyclomaticComplexity
+      # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
       def dispatch_node(node)
         case node.type
         when *ARGUMENT_DECLARATION_TYPES
@@ -124,16 +124,17 @@ module RuboCop
           process_scope(node)
         end
       end
-      # rubocop:enable Style/MethodLength, Style/CyclomaticComplexity
+      # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
       def process_variable_declaration(node)
-        # restarg would have no name:
+        variable_name = node.children.first
+
+        # restarg and kwrestarg would have no name:
         #
         #   def initialize(*)
         #   end
-        return if node.type == :restarg && node.children.empty?
+        return unless variable_name
 
-        variable_name = node.children.first
         variable_table.declare_variable(variable_name, node)
       end
 

data/lib/rubocop/formatter/base_formatter.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-# rubocop:disable Style/LineLength, Lint/UnusedMethodArgument
+# rubocop:disable Metrics/LineLength, Lint/UnusedMethodArgument
 
 module RuboCop
   module Formatter
@@ -41,7 +41,7 @@ module RuboCop
     # * `#finished`
     #
     class BaseFormatter
-      # rubocop:enable Style/LineLength
+      # rubocop:enable Metrics/LineLength
 
       # @api public
       #

data/lib/rubocop/processed_source.rb

@@ -5,14 +5,16 @@ module RuboCop
   # and other information such as disabled lines for cops.
   # It also provides a convenient way to access source lines.
   class ProcessedSource
+    STRING_SOURCE_NAME = '(string)'
     attr_reader :path, :buffer, :ast, :comments, :tokens, :diagnostics,
-                :parser_error
+                :parser_error, :raw_source
 
     def self.from_file(path)
       new(File.read(path), path)
     end
 
     def initialize(source, path = nil)
+      @raw_source = source
       @path = path
       @diagnostics = []
       parse(source)
@@ -27,21 +29,7 @@ module RuboCop
     end
 
     def lines
-      if @lines
-        @lines
-      else
-        init_lines
-        @lines
-      end
-    end
-
-    def raw_lines
-      if @raw_lines
-        @raw_lines
-      else
-        init_lines
-        @raw_lines
-      end
+      @lines ||= raw_source.lines.map(&:chomp)
     end
 
     def [](*args)
@@ -56,7 +44,7 @@ module RuboCop
     private
 
     def parse(source)
-      buffer_name = @path || '(string)'
+      buffer_name = @path || STRING_SOURCE_NAME
       @buffer = Parser::Source::Buffer.new(buffer_name, 1)
 
       begin
@@ -90,10 +78,5 @@ module RuboCop
         end
       end
     end
-
-    def init_lines
-      @raw_lines = @buffer.source.lines
-      @lines = @raw_lines.map(&:chomp)
-    end
   end
 end

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.24.1'
+    STRING = '0.25.0'
 
     MSG = '%s (using Parser %s, running on %s %s %s)'
 

data/relnotes/v0.25.0.md

@@ -0,0 +1,91 @@
+This release comes with lots of bug fixes and several new cops (that will likely need bugfixes in the next release :-)).
+
+The most notable change in 0.25 is the addition of the `Metrics` namespace. Several `Style` cops have been moved there
+(e.g. `ClassLength`, `MethodLength`, etc).
+
+This release also marks the end of us supporting Ruby 1.9.2 - now Ruby 1.9.3+ is required.
+
+Below is the list of all the gory details. Enjoy!
+
+### New features
+
+* [#1259](https://github.com/bbatsov/rubocop/issues/1259): Allow AndOr cop to autocorrect by adding method call parenthesis. ([@vrthra][])
+* [#1232](https://github.com/bbatsov/rubocop/issues/1232): Add EnforcedStyle option to cop `AndOr` to restrict it to conditionals. ([@vrthra][])
+* [#835](https://github.com/bbatsov/rubocop/issues/835): New cop `PercentQLiterals` checks if use of `%Q` and `%q` matches configuration. ([@jonas054][])
+* [#835](https://github.com/bbatsov/rubocop/issues/835): New cop `BarePercentLiterals` checks if usage of `%()` or `%Q()` matches configuration. ([@jonas054][])
+* [#1079](https://github.com/bbatsov/rubocop/pull/1079): New cop `MultilineBlockLayout` checks if a multiline block has an extpression on the same line as the start of the block. ([@barunio][])
+* [#1217](https://github.com/bbatsov/rubocop/pull/1217): `Style::EmptyLinesAroundAccessModifier` cop does auto-correction. ([@tamird][])
+* [#1220](https://github.com/bbatsov/rubocop/issues/1220): New cop `PerceivedComplexity` is similar to `CyclomaticComplexity`, but reports when methods have a high complexity for a human reader. ([@jonas054][])
+* `Debugger` cop now checks for `binding.pry_remote`. ([@yous][])
+* [#1238](https://github.com/bbatsov/rubocop/issues/1238): Add `MinBodyLength` option to `Next` cop. ([@bbatsov][])
+* [#1241](https://github.com/bbatsov/rubocop/issues/1241): `TrailingComma` cop does auto-correction. ([@yous][])
+* [#1078](https://github.com/bbatsov/rubocop/pull/1078): New cop `BlockEndNewline` checks if the end statement of a multiline block is on its own line. ([@barunio][])
+* [#1078](https://github.com/bbatsov/rubocop/pull/1078): `BlockAlignment` cop does auto-correction. ([@barunio][])
+
+### Changes
+
+* [#1220](https://github.com/bbatsov/rubocop/issues/1220): New namespace `Metrics` created and some `Style` cops moved there. ([@jonas054][])
+* Drop support for Ruby 1.9.2 in accordance with [the end of the security maintenance extension](https://www.ruby-lang.org/en/news/2014/07/01/eol-for-1-8-7-and-1-9-2/). ([@yujinakayama][])
+
+### Bugs fixed
+
+* [#1251](https://github.com/bbatsov/rubocop/issues/1251): Fix `PercentLiteralDelimiters` auto-correct indentation error. ([@hannestyden][])
+* [#1197](https://github.com/bbatsov/rubocop/issues/1197): Fix false positive for new lambda syntax in `SpaceInsideBlockBraces`. ([@jonas054][])
+* [#1201](https://github.com/bbatsov/rubocop/issues/1201): Fix error at anonymous keyword splat arguments in some variable cops. ([@yujinakayama][])
+* Fix false positive in `UnneededPercentQ` for `/%Q(something)/`. ([@jonas054][])
+* Fix `SpacesInsideBrackets` for `Hash#[]` calls with spaces after left bracket. ([@mcls][])
+* [#1210](https://github.com/bbatsov/rubocop/issues/1210): Fix false positive in `UnneededPercentQ` for `%Q(\t")`. ([@jonas054][])
+* Fix false positive in `UnneededPercentQ` for heredoc strings with `%q`/`%Q`. ([@jonas054][])
+* [#1214](https://github.com/bbatsov/rubocop/issues/1214): Don't destroy code in `AlignHash` autocorrect. ([@jonas054][])
+* [#1219](https://github.com/bbatsov/rubocop/issues/1219): Don't report bad alignment for `end` or `}` in `BlockAlignment` if it doesn't begin its line. ([@jonas054][])
+* [#1227](https://github.com/bbatsov/rubocop/issues/1227): Don't permanently change yamler as it can affect other apps. ([@jonas054][])
+* [#1184](https://github.com/bbatsov/rubocop/issues/1184): Fix a false positive in `Output` cop. ([@bbatsov][])
+* [#1256](https://github.com/bbatsov/rubocop/issues/1256): Ignore block-pass in `TrailingComma`. ([@tamird][])
+* [#1255](https://github.com/bbatsov/rubocop/issues/1255): Compare without context in `AutocorrectUnlessChangingAST`. ([@jonas054][])
+* [#1262](https://github.com/bbatsov/rubocop/issues/1262): Handle regexp and backtick literals in `VariableInterpolation`. ([@bbatsov][])
+
+[@bbatsov]: https://github.com/bbatsov
+[@jonas054]: https://github.com/jonas054
+[@yujinakayama]: https://github.com/yujinakayama
+[@dblock]: https://github.com/dblock
+[@nevir]: https://github.com/nevir
+[@daviddavis]: https://github.com/daviddavis
+[@sds]: https://github.com/sds
+[@fancyremarker]: https://github.com/fancyremarker
+[@sinisterchipmunk]: https://github.com/sinisterchipmunk
+[@vonTronje]: https://github.com/vonTronje
+[@agrimm]: https://github.com/agrimm
+[@pmenglund]: https://github.com/pmenglund
+[@chulkilee]: https://github.com/chulkilee
+[@codez]: https://github.com/codez
+[@emou]: https://github.com/emou
+[@skanev]: http://github.com/skanev
+[@claco]: http://github.com/claco
+[@rifraf]: http://github.com/rifraf
+[@scottmatthewman]: https://github.com/scottmatthewman
+[@ma2gedev]: http://github.com/ma2gedev
+[@jeremyolliver]: https://github.com/jeremyolliver
+[@hannestyden]: https://github.com/hannestyden
+[@geniou]: https://github.com/geniou
+[@jkogara]: https://github.com/jkogara
+[@tmorris-fiksu]: https://github.com/tmorris-fiksu
+[@mockdeep]: https://github.com/mockdeep
+[@hiroponz]: https://github.com/hiroponz
+[@tamird]: https://github.com/tamird
+[@fshowalter]: https://github.com/fshowalter
+[@cschramm]: https://github.com/cschramm
+[@bquorning]: https://github.com/bquorning
+[@bcobb]: https://github.com/bcobb
+[@irrationalfab]: https://github.com/irrationalfab
+[@tommeier]: https://github.com/tommeier
+[@sfeldon]: https://github.com/sfeldon
+[@biinari]: https://github.com/biinari
+[@barunio]: https://github.com/barunio
+[@molawson]: https://github.com/molawson
+[@wndhydrnt]: https://github.com/wndhydrnt
+[@ggilder]: https://github.com/ggilder
+[@salbertson]: https://github.com/salbertson
+[@camilleldn]: https://github.com/camilleldn
+[@mcls]: https://github.com/mcls
+[@yous]: https://github.com/yous
+[@vrthra]: https://github.com/vrthra