rubocop 0.35.1 → 0.36.0

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
       # This cop checks whether the source file has a utf-8 encoding
       # comment or not. This check makes sense only for code that
       # should support Ruby 1.9, since in 2.0+ utf-8 is the default
-      # source file encoding. There are two style:
+      # source file encoding. There are two styles:
       #
       # when_needed - only enforce an encoding comment if there are non ASCII
       #               characters, otherwise report an offense
@@ -14,9 +15,9 @@ module RuboCop
       class Encoding < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_MISSING = 'Missing utf-8 encoding comment.'
-        MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
-        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/.freeze
+        MSG_MISSING = 'Missing utf-8 encoding comment.'.freeze
+        MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'.freeze
+        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/
         AUTO_CORRECT_ENCODING_COMMENT = 'AutoCorrectEncodingComment'.freeze
         SHEBANG = '#!'.freeze
 
@@ -29,18 +30,14 @@ module RuboCop
           return unless message
 
           range = source_range(processed_source.buffer, line_number + 1, 0)
-          add_offense(processed_source.tokens.first, range, message)
+          add_offense(range, range, message)
         end
 
-        def autocorrect(node)
+        def autocorrect(range)
           encoding = cop_config[AUTO_CORRECT_ENCODING_COMMENT]
           if encoding && encoding =~ ENCODING_PATTERN
             lambda do |corrector|
-              if encoding_line_number(processed_source) == 0
-                corrector.insert_before(node.pos, "#{encoding}\n")
-              else
-                corrector.insert_after(node.pos, "\n#{encoding}")
-              end
+              corrector.insert_before(range, "#{encoding}\n")
             end
           else
             fail "#{encoding} does not match #{ENCODING_PATTERN}"

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

@@ -1,11 +1,13 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for END blocks.
       class EndBlock < Cop
-        MSG = 'Avoid the use of `END` blocks. Use `Kernel#at_exit` instead.'
+        MSG = 'Avoid the use of `END` blocks. ' \
+              'Use `Kernel#at_exit` instead.'.freeze
 
         def on_postexe(node)
           add_offense(node, :keyword)

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

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for Windows-style line endings in the source code.
       class EndOfLine < Cop
-        MSG = 'Carriage return character detected.'
+        MSG = 'Carriage return character detected.'.freeze
 
         def investigate(processed_source)
           last_token = processed_source.tokens.last

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -14,7 +15,7 @@ module RuboCop
       #   # good
       #   if x.even?
       class EvenOdd < Cop
-        MSG = 'Replace with `Fixnum#%s?`.'
+        MSG = 'Replace with `Fixnum#%s?`.'.freeze
 
         ZERO = s(:int, 0)
         ONE = s(:int, 1)
@@ -27,7 +28,7 @@ module RuboCop
 
         def autocorrect(node)
           correction = "#{base_number(node)}.#{offense_type(node)}?"
-          ->(corrector) { corrector.replace(node.loc.expression, correction) }
+          ->(corrector) { corrector.replace(node.source_range, correction) }
         end
 
         private
@@ -35,7 +36,7 @@ module RuboCop
         def base_number(node)
           receiver, = *node
           node = expression(receiver)
-          node.children[0].loc.expression.source
+          node.children[0].source
         end
 
         def offense_type(node)

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

@@ -1,4 +1,7 @@
 # encoding: utf-8
+# frozen_string_literal: true
+
+require 'set'
 
 module RuboCop
   module Cop
@@ -18,35 +21,85 @@ module RuboCop
       #   set_app("RuboCop")
       #   website  = "https://github.com/bbatsov/rubocop"
       class ExtraSpacing < Cop
-        MSG = 'Unnecessary spacing detected.'
+        include PrecedingFollowingAlignment
+
+        MSG_UNNECESSARY = 'Unnecessary spacing detected.'.freeze
+        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %s assignment.'.freeze
 
         def investigate(processed_source)
           ast = processed_source.ast
 
+          if force_equal_sign_alignment?
+            @asgn_tokens = processed_source.tokens.select { |t| equal_sign?(t) }
+            # Only attempt to align the first = on each line
+            @asgn_tokens = Set.new(@asgn_tokens.uniq { |t| t.pos.line })
+            @asgn_lines  = @asgn_tokens.map { |t| t.pos.line }
+            # Don't attempt to correct the same = more than once
+            @corrected   = Set.new
+          end
+
           processed_source.tokens.each_cons(2) do |t1, t2|
             next if t2.type == :tNL
-            next if t1.pos.line != t2.pos.line
-            next if t2.pos.begin_pos - 1 <= t1.pos.end_pos
-            next if allow_for_alignment? && aligned_with_something?(t2)
-            start_pos = t1.pos.end_pos
-            next if ignored_ranges(ast).find { |r| r.include?(start_pos) }
-
-            end_pos = t2.pos.begin_pos - 1
-            range = Parser::Source::Range.new(processed_source.buffer,
-                                              start_pos, end_pos)
-            # Unary + doesn't appear as a token and needs special handling.
-            next if unary_plus_non_offense?(range)
-
-            add_offense(range, range, MSG)
+
+            if force_equal_sign_alignment? &&
+               @asgn_tokens.include?(t2) &&
+               (@asgn_lines.include?(t2.pos.line - 1) ||
+                @asgn_lines.include?(t2.pos.line + 1))
+              check_assignment(t2)
+            else
+              check_other(t1, t2, ast)
+            end
           end
         end
 
         def autocorrect(range)
-          ->(corrector) { corrector.remove(range) }
+          lambda do |corrector|
+            if range.source.end_with?('=')
+              align_equal_sign(range, corrector)
+            else
+              corrector.remove(range)
+            end
+          end
         end
 
         private
 
+        def check_assignment(token)
+          # minus 2 is because pos.line is zero-based
+          line = processed_source.lines[token.pos.line - 2]
+          return if aligned_assignment?(token.pos, line)
+
+          preceding  = @asgn_lines.include?(token.pos.line - 1)
+          align_with = preceding ? 'preceding' : 'following'
+          message    = format(MSG_UNALIGNED_ASGN, align_with)
+          add_offense(token.pos, token.pos, message)
+        end
+
+        def check_other(t1, t2, ast)
+          return if t1.pos.line != t2.pos.line
+          return if t2.pos.begin_pos - 1 <= t1.pos.end_pos
+          return if allow_for_alignment? && aligned_tok?(t2)
+
+          start_pos = t1.pos.end_pos
+          return if ignored_ranges(ast).find { |r| r.include?(start_pos) }
+
+          end_pos = t2.pos.begin_pos - 1
+          range = Parser::Source::Range.new(processed_source.buffer,
+                                            start_pos, end_pos)
+          # Unary + doesn't appear as a token and needs special handling.
+          return if unary_plus_non_offense?(range)
+
+          add_offense(range, range, MSG_UNNECESSARY)
+        end
+
+        def aligned_tok?(token)
+          if token.type == :tCOMMENT
+            aligned_comments?(token)
+          else
+            aligned_with_something?(token.pos)
+          end
+        end
+
         def unary_plus_non_offense?(range)
           range.resize(range.size + 1).source =~ /^ ?\+$/
         end
@@ -57,35 +110,12 @@ module RuboCop
         def ignored_ranges(ast)
           return [] unless ast
 
-          @ignored_ranges ||= begin
-            ranges = []
-            on_node(:pair, ast) do |pair|
-              key, value = *pair
-              r = key.loc.expression.end_pos...value.loc.expression.begin_pos
-              ranges << r
-            end
-            ranges
+          @ignored_ranges ||= on_node(:pair, ast).map do |pair|
+            key, value = *pair
+            key.source_range.end_pos...value.source_range.begin_pos
           end
         end
 
-        def allow_for_alignment?
-          cop_config['AllowForAlignment']
-        end
-
-        def aligned_with_something?(token)
-          return aligned_comments?(token) if token.type == :tCOMMENT
-
-          pre = (token.pos.line - 2).downto(0)
-          post = token.pos.line.upto(processed_source.lines.size - 1)
-          return true if aligned_with?(pre, token) || aligned_with?(post, token)
-
-          # If no aligned token was found, search for an aligned token on the
-          # nearest line with the same indentation as the checked line.
-          base_indentation = processed_source.lines[token.pos.line - 1] =~ /\S/
-          aligned_with?(pre, token, base_indentation) ||
-            aligned_with?(post, token, base_indentation)
-        end
-
         def aligned_comments?(token)
           ix = processed_source.comments.index do |c|
             c.loc.expression.begin_pos == token.pos.begin_pos
@@ -106,47 +136,53 @@ module RuboCop
           processed_source.comments[ix].loc.column
         end
 
-        # Returns true if the previous or next line, not counting empty or
-        # comment lines, contains a token that's aligned with the given
-        # token. If base_indentation is given, lines with different indentation
-        # than the base indentation are also skipped.
-        def aligned_with?(indices_to_check, token, base_indentation = nil)
-          indices_to_check.each do |ix|
-            next if comment_lines.include?(ix + 1)
-            line = processed_source.lines[ix]
-            next if line.strip.empty?
-            if base_indentation
-              indentation = line =~ /\S/
-              next if indentation != base_indentation
-            end
-            return (aligned_words?(token, line) ||
-                    aligned_assignments?(token, line) ||
-                    aligned_same_character?(token, line))
-          end
-          false # No line to check was found.
+        def force_equal_sign_alignment?
+          cop_config['ForceEqualSignAlignment']
         end
 
-        def comment_lines
-          @comment_lines ||=
-            begin
-              whole_line_comments = processed_source.comments.select do |c|
-                begins_its_line?(c.loc.expression)
-              end
-              whole_line_comments.map { |c| c.loc.line }
-            end
+        def equal_sign?(token)
+          token.type == :tEQL || token.type == :tOP_ASGN
         end
 
-        def aligned_words?(token, line)
-          line[token.pos.column - 1, 2] =~ /\s\S/
+        def align_equal_sign(range, corrector)
+          lines  = contiguous_assignment_lines(range)
+          tokens = @asgn_tokens.select { |t| lines.include?(t.pos.line) }
+
+          columns  = tokens.map { |t| align_column(t) }
+          align_to = columns.max
+
+          tokens.each do |token|
+            next unless @corrected.add?(token)
+            diff = align_to - token.pos.last_column
+
+            if diff > 0
+              corrector.insert_before(token.pos, ' ' * diff)
+            elsif diff < 0
+              corrector.remove_preceding(token.pos, -diff)
+            end
+          end
         end
 
-        def aligned_assignments?(token, line)
-          token.type == :tOP_ASGN &&
-            line[token.pos.column + token.text.length] == '='
+        def contiguous_assignment_lines(range)
+          result = [range.line]
+
+          range.line.downto(1) do |lineno|
+            @asgn_lines.include?(lineno) ? result << lineno : break
+          end
+          range.line.upto(processed_source.lines.size) do |lineno|
+            @asgn_lines.include?(lineno) ? result << lineno : break
+          end
+
+          result.sort!
         end
 
-        def aligned_same_character?(token, line)
-          line[token.pos.column] == token.text.to_s[0]
+        def align_column(asgn_token)
+          # if we removed unneeded spaces from the beginning of this =,
+          # what column would it end from?
+          line    = processed_source.lines[asgn_token.pos.line - 1]
+          leading = line[0...asgn_token.pos.column]
+          spaces  = leading.size - (leading =~ / *\Z/)
+          asgn_token.pos.last_column - spaces + 1
         end
       end
     end

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

@@ -1,11 +1,19 @@
 # encoding: utf-8
+# frozen_string_literal: true
+
+require 'pathname'
 
 module RuboCop
   module Cop
     module Style
-      # This cop makes sure that Ruby source files have snake_case names.
+      # This cop makes sure that Ruby source files have snake_case
+      # names. Ruby scripts (i.e. source files with a shebang in the
+      # first line) are ignored.
       class FileName < Cop
-        MSG = 'Use snake_case for source file names.'
+        MSG_SNAKE_CASE = 'Use snake_case for source file names.'.freeze
+        MSG_NO_DEFINITION = '%s should define a class or module ' \
+                            'called `%s`.'.freeze
+        MSG_REGEX = '`%s` should match `%s`.'.freeze
 
         SNAKE_CASE = /^[\da-z_]+$/
 
@@ -13,11 +21,25 @@ module RuboCop
           file_path = processed_source.buffer.name
           return if config.file_to_include?(file_path)
 
-          basename = File.basename(file_path).sub(/\.[^\.]+$/, '')
-          return if snake_case?(basename)
+          basename = File.basename(file_path)
+          if filename_good?(basename)
+            return unless expect_matching_definition?
+            return if find_class_or_module(processed_source.ast,
+                                           to_namespace(file_path))
+            range = source_range(processed_source.buffer, 1, 0)
+            msg   = format(MSG_NO_DEFINITION,
+                           basename,
+                           to_namespace(file_path).join('::'))
+          else
+            first_line = processed_source.lines.first
+            return if cop_config['IgnoreExecutableScripts'] &&
+                      shebang?(first_line)
+
+            range = source_range(processed_source.buffer, 1, 0)
+            msg = regex ? format(MSG_REGEX, basename, regex) : MSG_SNAKE_CASE
+          end
 
-          range = source_range(processed_source.buffer, 1, 0)
-          add_offense(nil, range)
+          add_offense(nil, range, msg)
         end
 
         private
@@ -25,6 +47,81 @@ module RuboCop
         def snake_case?(basename)
           basename.split('.').all? { |fragment| fragment =~ SNAKE_CASE }
         end
+
+        def shebang?(line)
+          line.start_with?('#!')
+        end
+
+        def expect_matching_definition?
+          cop_config['ExpectMatchingDefinition']
+        end
+
+        def regex
+          cop_config['Regex']
+        end
+
+        def filename_good?(basename)
+          basename = basename.sub(/\.[^\.]+$/, '')
+          regex ? basename =~ regex : snake_case?(basename)
+        end
+
+        def find_class_or_module(node, namespace)
+          return nil if node.nil?
+          name = namespace.pop
+
+          on_node([:class, :module, :casgn], node) do |child|
+            next unless (const = child.defined_module)
+
+            const_namespace, const_name = *const
+            next unless name == const_name
+
+            return node if namespace.empty?
+            return node if match_namespace(child, const_namespace, namespace)
+          end
+          nil
+        end
+
+        def match_namespace(node, namespace, expected)
+          expected = expected.dup
+
+          match_partial = lambda do |ns|
+            next if ns.nil?
+            while ns
+              return expected.empty? || expected == [:Object] if ns.cbase_type?
+              ns, name = *ns
+              name == expected.last ? expected.pop : (return false)
+            end
+          end
+
+          match_partial.call(namespace)
+
+          node.each_ancestor(:class, :module, :sclass, :casgn) do |ancestor|
+            return false if ancestor.sclass_type?
+            match_partial.call(ancestor.defined_module)
+          end
+
+          expected.empty? || expected == [:Object]
+        end
+
+        def to_namespace(path)
+          components = Pathname(path).each_filename.to_a
+          # To convert a pathname to a Ruby namespace, we need a starting point
+          # But RC can be run from any working directory, and can check any path
+          # We can't assume that the working directory, or any other, is the
+          # "starting point" to build a namespace
+          start = %w(lib spec test src)
+          if components.find { |c| start.include?(c) }
+            components = components.drop_while { |c| !start.include?(c) }
+            components.drop(1).map { |fn| to_module_name(fn) }
+          else
+            [to_module_name(components.last)]
+          end
+        end
+
+        def to_module_name(basename)
+          words = basename.sub(/\..*/, '').split('_')
+          words.map(&:capitalize).join.to_sym
+        end
       end
     end
   end