rubocop 0.14.1 → 0.15.0

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

@@ -28,6 +28,12 @@ module Rubocop
         def elsif?(node)
           node.loc.keyword.is?('elsif')
         end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            corrector.insert_before(node.loc.keyword, ' ')
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+# rubocop:disable SymbolName
+
+module Rubocop
+  module Cop
+    module Style
+      # Common functionality for checking for spaces inside various
+      # kinds of parentheses.
+      module SpaceInside
+        include SurroundingSpace
+        MSG = 'Space inside %s detected.'
+
+        def investigate(processed_source)
+          @processed_source = processed_source
+          left, right, kind = specifics
+          processed_source.tokens.each_cons(2) do |t1, t2|
+            if t1.type == left || t2.type == right
+              if t2.pos.line == t1.pos.line && space_between?(t1, t2)
+                range = Parser::Source::Range.new(processed_source.buffer,
+                                                  t1.pos.end_pos,
+                                                  t2.pos.begin_pos)
+                convention(range, range, format(MSG, kind))
+              end
+            end
+          end
+        end
+
+        def autocorrect(range)
+          @corrections << ->(corrector) { corrector.remove(range) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+# rubocop:disable SymbolName
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for spaces inside square brackets.
+      class SpaceInsideBrackets < Cop
+        include SpaceInside
+
+        def specifics
+          [:tLBRACK, :tRBRACK, 'square brackets']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+# rubocop:disable SymbolName
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks that braces used for hash literals have or don't have
+      # surrounding space depending on configuration.
+      class SpaceInsideHashLiteralBraces < Cop
+        include SurroundingSpace
+        MSG = 'Space inside %s.'
+
+        def investigate(processed_source)
+          return unless processed_source.ast
+          tokens = processed_source.tokens
+
+          on_node(:hash, processed_source.ast) do |hash|
+            b_ix = index_of_first_token(hash)
+            if tokens[b_ix].type == :tLBRACE # Hash literal with braces?
+              e_ix = index_of_last_token(hash)
+              check(tokens[b_ix], tokens[b_ix + 1])
+              check(tokens[e_ix - 1], tokens[e_ix]) unless b_ix == e_ix - 1
+            end
+          end
+        end
+
+        private
+
+        def check(t1, t2)
+          # No offence if line break inside.
+          return if t1.pos.line < t2.pos.line
+
+          is_empty_braces = t1.text == '{' && t2.text == '}'
+          expect_space = if is_empty_braces
+                           cop_config['EnforcedStyleForEmptyBraces'] == 'space'
+                         else
+                           cop_config['EnforcedStyle'] == 'space'
+                         end
+          if offence?(t1, t2, expect_space)
+            brace = (t1.text == '{' ? t1 : t2).pos
+            range = expect_space ? brace : space_range(brace)
+            convention(range, range,
+                       message(brace, is_empty_braces, expect_space))
+          end
+        end
+
+        def offence?(t1, t2, expect_space)
+          has_space = space_between?(t1, t2)
+          expect_space ? !has_space : has_space
+        end
+
+        def message(brace, is_empty_braces, expect_space)
+          inside_what = if is_empty_braces
+                          'empty hash literal braces'
+                        else
+                          brace.source
+                        end
+          problem = expect_space ? 'missing' : 'detected'
+          sprintf(MSG, "#{inside_what} #{problem}")
+        end
+
+        def autocorrect(range)
+          @corrections << lambda do |corrector|
+            case range.source
+            when /\s/ then corrector.remove(range)
+            when '{' then corrector.insert_after(range, ' ')
+            else corrector.insert_before(range, ' ')
+            end
+          end
+        end
+
+        def space_range(token_range)
+          if token_range.source == '{'
+            range_of_space_to_the_right(token_range)
+          else
+            range_of_space_to_the_left(token_range)
+          end
+        end
+
+        def range_of_space_to_the_right(range)
+          src = range.source_buffer.source
+          end_pos = range.end_pos
+          end_pos += 1 while src[end_pos] =~ /[ \t]/
+          Parser::Source::Range.new(range.source_buffer,
+                                    range.begin_pos + 1, end_pos)
+        end
+
+        def range_of_space_to_the_left(range)
+          src = range.source_buffer.source
+          begin_pos = range.begin_pos
+          begin_pos -= 1 while src[begin_pos - 1] =~ /[ \t]/
+          Parser::Source::Range.new(range.source_buffer, begin_pos,
+                                    range.end_pos - 1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+# rubocop:disable SymbolName
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for spaces inside ordinary round parentheses.
+      class SpaceInsideParens < Cop
+        include SpaceInside
+
+        def specifics
+          [:tLPAREN2, :tRPAREN, 'parentheses']
+        end
+      end
+    end
+  end
+end

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

@@ -5,33 +5,43 @@ module Rubocop
     module Style
       # This cop looks for uses of Perl-style global variables.
       class SpecialGlobalVars < Cop
-        MSG = 'Prefer %s over %s.'
+        MSG_BOTH = 'Prefer %s from the English library, or %s over %s.'
+        MSG_ENGLISH = 'Prefer %s from the English library over %s.'
+        MSG_REGULAR = 'Prefer %s over %s.'
 
         PREFERRED_VARS = {
-          '$:' => '$LOAD_PATH',
-          '$"' => '$LOADED_FEATURES',
-          '$0' => '$PROGRAM_NAME',
-          '$!' => '$ERROR_INFO from English library',
-          '$@' => '$ERROR_POSITION from English library',
-          '$;' => '$FS or $FIELD_SEPARATOR from English library',
-          '$,' => '$OFS or $OUTPUT_FIELD_SEPARATOR from English library',
-          '$/' => '$RS or $INPUT_RECORD_SEPARATOR from English library',
-          '$\\' => '$ORS or $OUTPUT_RECORD_SEPARATOR from English library',
-          '$.' => '$NR or $INPUT_LINE_NUMBER from English library',
-          '$_' => '$LAST_READ_LINE from English library',
-          '$>' => '$DEFAULT_OUTPUT from English library',
-          '$<' => '$DEFAULT_INPUT from English library',
-          '$$' => '$PID or $PROCESS_ID from English library',
-          '$?' => '$CHILD_STATUS from English library',
-          '$~' => '$LAST_MATCH_INFO from English library',
-          '$=' => '$IGNORECASE from English library',
-          '$*' => '$ARGV from English library or ARGV constant',
-          '$&' => '$MATCH from English library',
-          '$`' => '$PREMATCH from English library',
-          '$\'' => '$POSTMATCH from English library',
-          '$+' => '$LAST_PAREN_MATCH from English library'
+          '$:' => ['$LOAD_PATH'],
+          '$"' => ['$LOADED_FEATURES'],
+          '$0' => ['$PROGRAM_NAME'],
+          '$!' => ['$ERROR_INFO'],
+          '$@' => ['$ERROR_POSITION'],
+          '$;' => ['$FIELD_SEPARATOR', '$FS'],
+          '$,' => ['$OUTPUT_FIELD_SEPARATOR', '$OFS'],
+          '$/' => ['$INPUT_RECORD_SEPARATOR', '$RS'],
+          '$\\' => ['$OUTPUT_RECORD_SEPARATOR', '$ORS'],
+          '$.' => ['$INPUT_LINE_NUMBER', '$NR'],
+          '$_' => ['$LAST_READ_LINE'],
+          '$>' => ['$DEFAULT_OUTPUT'],
+          '$<' => ['$DEFAULT_INPUT'],
+          '$$' => ['$PROCESS_ID', '$PID'],
+          '$?' => ['$CHILD_STATUS'],
+          '$~' => ['$LAST_MATCH_INFO'],
+          '$=' => ['$IGNORECASE'],
+          '$*' => ['$ARGV', 'ARGV'],
+          '$&' => ['$MATCH'],
+          '$`' => ['$PREMATCH'],
+          '$\'' => ['$POSTMATCH'],
+          '$+' => ['$LAST_PAREN_MATCH']
         }.symbolize_keys
 
+        # Anything *not* in this set is provided by the English library.
+        NON_ENGLISH_VARS = Set.new([
+          '$LOAD_PATH',
+          '$LOADED_FEATURES',
+          '$PROGRAM_NAME',
+          'ARGV'
+        ])
+
         def on_gvar(node)
           global_var, = *node
 
@@ -40,7 +50,24 @@ module Rubocop
 
         def message(node)
           global_var, = *node
-          MSG.format(PREFERRED_VARS[global_var], global_var)
+
+          regular, english = PREFERRED_VARS[global_var].partition do |var|
+            NON_ENGLISH_VARS.include? var
+          end
+
+          # For now, we assume that lists are 2 items or less.  Easy grammar!
+          regular_msg = regular.join(' or ')
+          english_msg = english.join(' or ')
+
+          if regular.length > 0 && english.length > 0
+            MSG_BOTH.format(english_msg, regular_msg, global_var)
+          elsif regular.length > 0
+            MSG_REGULAR.format(regular_msg, global_var)
+          elsif english.length > 0
+            MSG_ENGLISH.format(english_msg, global_var)
+          else
+            fail 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
+          end
         end
 
         def autocorrect(node)
@@ -48,7 +75,7 @@ module Rubocop
             global_var, = *node
 
             corrector.replace(node.loc.expression,
-                              PREFERRED_VARS[global_var])
+                              PREFERRED_VARS[global_var].first)
           end
         end
       end

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

@@ -21,7 +21,7 @@ module Rubocop
 
         def offence?(node)
           src = node.loc.expression.source
-          return false if src =~ /^%q/i
+          return false if src =~ /^(%q|\?)/i
           src !~ if single_quotes_preferred?
                    # regex matches IF there is a ' or there is a \\ in the
                    # string that is not preceeded/followed by another \\

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

@@ -15,7 +15,7 @@ module Rubocop
             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 == ' '
+          t2.pos.line > t1.pos.line || char_preceding_2nd_token =~ /[ \t]/
         end
 
         def index_of_first_token(node)
@@ -41,349 +41,6 @@ module Rubocop
           end
         end
       end
-
-      # Checks that operators have space around them, except for **
-      # which should not have surrounding space.
-      class SpaceAroundOperators < Cop
-        include SurroundingSpace
-        MSG_MISSING = "Surrounding space missing for operator '%s'."
-        MSG_DETECTED = 'Space around operator ** detected.'
-
-        BINARY_OPERATORS =
-          [:tEQL,    :tAMPER2,  :tPIPE,  :tCARET, :tPLUS,  :tMINUS, :tSTAR2,
-           :tDIVIDE, :tPERCENT, :tEH,    :tCOLON, :tANDOP, :tOROP,  :tMATCH,
-           :tNMATCH, :tEQ,      :tNEQ,   :tGT,    :tRSHFT, :tGEQ,   :tLT,
-           :tLSHFT,  :tLEQ,     :tASSOC, :tEQQ,   :tCMP,   :tOP_ASGN]
-
-        def investigate(processed_source)
-          return unless processed_source.ast
-          @processed_source = processed_source
-          tokens = processed_source.tokens
-          tokens.each_cons(3) do |token_before, token, token_after|
-            next if token_before.type == :kDEF # TODO: remove?
-            next if token_before.type == :tDOT # Called as method.
-            next if positions_not_to_check.include?(token.pos)
-
-            case token.type
-            when :tPOW
-              if has_space?(token_before, token, token_after)
-                convention(nil, token.pos, MSG_DETECTED)
-              end
-            when *BINARY_OPERATORS
-              check_missing_space(token_before, token, token_after)
-            end
-          end
-        end
-
-        # Returns an array of positions marking the tokens that this cop
-        # should not check, either because the token is not an operator
-        # or because another cop does the check.
-        def positions_not_to_check
-          @positions_not_to_check ||= begin
-            positions = []
-            positions.concat(do_not_check_block_arg_pipes)
-            positions.concat(do_not_check_param_default)
-            positions.concat(do_not_check_class_lshift_self)
-            positions.concat(do_not_check_def_things)
-            positions.concat(do_not_check_singleton_operator_defs)
-            positions
-          end
-        end
-
-        def do_not_check_block_arg_pipes
-          # each { |a| }
-          #        ^ ^
-          positions = []
-          on_node(:block, @processed_source.ast) do |b|
-            on_node(:args, b) do |a|
-              positions << a.loc.begin << a.loc.end if a.loc.begin
-            end
-          end
-          positions
-        end
-
-        def do_not_check_param_default
-          # func(a, b=nil)
-          #          ^
-          positions = []
-          tokens = @processed_source.tokens
-          on_node(:optarg, @processed_source.ast) do |optarg|
-            _arg, equals, _value = tokens[index_of_first_token(optarg),
-                                          3]
-            positions << equals.pos
-          end
-          positions
-        end
-
-        def do_not_check_class_lshift_self
-          # class <<self
-          #       ^
-          positions = []
-          tokens = @processed_source.tokens
-          on_node(:sclass, @processed_source.ast) do |sclass|
-            ix = index_of_first_token(sclass)
-            if tokens[ix, 2].map(&:type) == [:kCLASS, :tLSHFT]
-              positions << tokens[ix + 1].pos
-            end
-          end
-          positions
-        end
-
-        def do_not_check_def_things
-          # def +(other)
-          #     ^
-          positions = []
-          tokens = @processed_source.tokens
-          on_node(:def, @processed_source.ast) do |def_node|
-            # def each &block
-            #          ^
-            # def each *args
-            #          ^
-            on_node([:blockarg, :restarg], def_node) do |arg_node|
-              positions << tokens[index_of_first_token(arg_node)].pos
-            end
-            positions << tokens[index_of_first_token(def_node) + 1].pos
-          end
-          positions
-        end
-
-        def do_not_check_singleton_operator_defs
-          # def self.===(other)
-          #          ^
-          positions = []
-          tokens = @processed_source.tokens
-          on_node(:defs, @processed_source.ast) do |defs_node|
-            _receiver, name, _args = *defs_node
-            ix = index_of_first_token(defs_node)
-            name_token = tokens[ix..-1].find { |t| t.text == name.to_s }
-            positions << name_token.pos
-          end
-          positions
-        end
-
-        def check_missing_space(token_before, token, token_after)
-          unless has_space?(token_before, token, token_after)
-            text = token.text.to_s + (token.type == :tOP_ASGN ? '=' : '')
-            convention(nil, token.pos, MSG_MISSING.format(text))
-          end
-        end
-
-        def has_space?(token_before, token, token_after)
-          space_between?(token_before, token) && space_between?(token,
-                                                                token_after)
-        end
-      end
-
-      # Checks that block braces have or don't have surrounding space depending
-      # on configuration. For blocks taking parameters, it checks that the left
-      # brace has or doesn't have trailing space depending on configuration.
-      class SpaceAroundBlockBraces < Cop
-        include SurroundingSpace
-
-        def investigate(processed_source)
-          return unless processed_source.ast
-          @processed_source = processed_source
-
-          processed_source.tokens.each_cons(2) do |t1, t2|
-            next if ([t1.pos, t2.pos] - positions_not_to_check).size < 2
-
-            type1, type2 = t1.type, t2.type
-            if [:tLCURLY, :tRCURLY].include?(type2)
-              check(t1, t2)
-            elsif type1 == :tLCURLY
-              if type2 == :tPIPE
-                check_pipe(t1, t2)
-              else
-                check(t1, t2)
-              end
-            end
-          end
-        end
-
-        def positions_not_to_check
-          @positions_not_to_check ||= begin
-            positions = []
-            ast = @processed_source.ast
-            tokens = @processed_source.tokens
-
-            on_node(:hash, ast) do |hash|
-              b_ix = index_of_first_token(hash)
-              e_ix = index_of_last_token(hash)
-              positions << tokens[b_ix].pos << tokens[e_ix].pos
-            end
-
-            # TODO: Check braces inside string/symbol/regexp/xstr
-            #   interpolation.
-            on_node([:dstr, :dsym, :regexp, :xstr], ast) do |s|
-              b_ix = index_of_first_token(s)
-              e_ix = index_of_last_token(s)
-              tokens[b_ix..e_ix].each do |t|
-                positions << t.pos if t.type == :tRCURLY
-              end
-            end
-
-            positions
-          end
-        end
-
-        def check(t1, t2)
-          if cop_config['EnforcedStyle'] == 'space_inside_braces'
-            check_space_inside_braces(t1, t2)
-          else
-            check_no_space_inside_braces(t1, t2)
-          end
-          check_space_outside_left_brace(t1, t2)
-        end
-
-        def check_space_inside_braces(t1, t2)
-          unless space_between?(t1, t2)
-            if t1.text == '{'
-              convention(nil, t1.pos, 'Space missing inside {.')
-            elsif t2.text == '}'
-              convention(nil, t2.pos, 'Space missing inside }.')
-            end
-          end
-        end
-
-        def check_no_space_inside_braces(t1, t2)
-          if t1.text == '{' || t2.text == '}'
-            if space_between?(t1, t2)
-              if t1.text == '{'
-                convention(nil, space_range(t1), 'Space inside { detected.')
-              elsif t2.text == '}'
-                convention(nil, space_range(t2), 'Space inside } detected.')
-              end
-            end
-          end
-        end
-
-        def check_space_outside_left_brace(t1, t2)
-          if t2.text == '{' && !space_between?(t1, t2)
-            convention(nil, t2.pos, 'Space missing to the left of {.')
-          end
-        end
-
-        def check_pipe(t1, t2)
-          if cop_config['SpaceBeforeBlockParameters']
-            unless space_between?(t1, t2)
-              convention(nil, t1.pos, 'Space between { and | missing.')
-            end
-          elsif space_between?(t1, t2)
-            convention(nil, space_range(t1), 'Space between { and | detected.')
-          end
-        end
-
-        def space_range(token)
-          src = @processed_source.buffer.source
-          if token.text == '{'
-            b = token.pos.begin_pos + 1
-            e = b + 1
-            e += 1 while src[e] =~ /\s/
-          else
-            e = token.pos.begin_pos
-            b = e - 1
-            b -= 1 while src[b - 1] =~ /\s/
-          end
-          Parser::Source::Range.new(@processed_source.buffer, b, e)
-        end
-      end
-
-      # Common functionality for checking for spaces inside various
-      # kinds of parentheses.
-      module SpaceInside
-        include SurroundingSpace
-        MSG = 'Space inside %s detected.'
-
-        def investigate(processed_source)
-          @processed_source = processed_source
-          left, right, kind = specifics
-          processed_source.tokens.each_cons(2) do |t1, t2|
-            if t1.type == left || t2.type == right
-              if t2.pos.line == t1.pos.line && space_between?(t1, t2)
-                range = Parser::Source::Range.new(processed_source.buffer,
-                                                  t1.pos.end_pos,
-                                                  t2.pos.begin_pos)
-                convention(nil, range, format(MSG, kind))
-              end
-            end
-          end
-        end
-      end
-
-      # Checks for spaces inside ordinary round parentheses.
-      class SpaceInsideParens < Cop
-        include SpaceInside
-
-        def specifics
-          [:tLPAREN2, :tRPAREN, 'parentheses']
-        end
-      end
-
-      # Checks for spaces inside square brackets.
-      class SpaceInsideBrackets < Cop
-        include SpaceInside
-
-        def specifics
-          [:tLBRACK, :tRBRACK, 'square brackets']
-        end
-      end
-
-      # Checks that braces used for hash literals have or don't have
-      # surrounding space depending on configuration.
-      class SpaceInsideHashLiteralBraces < Cop
-        include SurroundingSpace
-        MSG = 'Space inside hash literal braces %s.'
-
-        def investigate(processed_source)
-          return unless processed_source.ast
-          @processed_source = processed_source
-          tokens = processed_source.tokens
-
-          on_node(:hash, processed_source.ast) do |hash|
-            b_ix = index_of_first_token(hash)
-            e_ix = index_of_last_token(hash)
-            if tokens[b_ix].type == :tLBRACE # Hash literal with braces?
-              check(tokens[b_ix], tokens[b_ix + 1])
-              check(tokens[e_ix - 1], tokens[e_ix])
-            end
-          end
-        end
-
-        def check(t1, t2)
-          types = [t1, t2].map(&:type)
-          braces = [:tLBRACE, :tRCURLY]
-          return if types == braces || (braces - types).size == 2
-          # No offence if line break inside.
-          return if t1.pos.line < t2.pos.line
-          has_space = space_between?(t1, t2)
-          is_offence, word = if cop_config['EnforcedStyleIsWithSpaces']
-                               [!has_space, 'missing']
-                             else
-                               [has_space, 'detected']
-                             end
-          brace_token = t1.text == '{' ? t1 : t2
-          convention(nil, brace_token.pos, sprintf(MSG, word)) if is_offence
-        end
-      end
-
-      # Checks that the equals signs in parameter default assignments
-      # have surrounding space.
-      class SpaceAroundEqualsInParameterDefault < Cop
-        include SurroundingSpace
-        MSG = 'Surrounding space missing in default value assignment.'
-
-        def investigate(processed_source)
-          return unless processed_source.ast
-          @processed_source = processed_source
-          on_node(:optarg, processed_source.ast) do |optarg|
-            index = index_of_first_token(optarg)
-            arg, equals, value = processed_source.tokens[index, 3]
-            unless space_between?(arg, equals) && space_between?(equals, value)
-              convention(nil, equals.pos)
-            end
-          end
-        end
-      end
     end
   end
 end