rubocop 0.33.0 → 0.34.0

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop check for uses of Object#freeze on immutable objects.
+      #
+      # @example
+      #   # bad
+      #   CONST = 1.freeze
+      #
+      #   # good
+      #   CONST = 1
+      class RedundantFreeze < Cop
+        MSG = 'Freezing immutable objects is pointless.'.freeze
+
+        TARGET_NODES = [:int, :float, :sym].freeze
+
+        def on_send(node)
+          receiver, method_name, *args = *node
+
+          return unless receiver && TARGET_NODES.include?(receiver.type)
+          return unless method_name == :freeze && args.empty?
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.dot)
+            corrector.remove(node.loc.selector)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -65,7 +65,8 @@ module RuboCop
         end
 
         def modifier?(node)
-          @modifier_locations.include? node.loc.keyword
+          return false unless @modifier_locations.respond_to?(:include?)
+          @modifier_locations.include?(node.loc.keyword)
         end
 
         def ancestor_node(node)

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

@@ -5,14 +5,46 @@ module RuboCop
     module Style
       # This cop checks for uses of rescue in its modifier form.
       class RescueModifier < Cop
+        include AutocorrectAlignment
+
         MSG = 'Avoid using `rescue` in its modifier form.'
 
         def investigate(processed_source)
-          processed_source.tokens.each do |t|
-            next unless t.type == :kRESCUE_MOD
-            add_offense(nil, t.pos)
+          @modifier_locations = processed_source.tokens
+                                .select { |t| t.type == :kRESCUE_MOD }
+                                .map(&:pos)
+        end
+
+        def on_resbody(node)
+          return unless modifier?(node)
+          add_offense(node.parent, :expression)
+        end
+
+        def autocorrect(node)
+          operation, rescue_modifier, = *node
+          *_, rescue_args = *rescue_modifier
+
+          correction =
+            "begin\n" <<
+            indentation(node) << operation.loc.expression.source <<
+            "\n#{offset(node)}rescue\n" <<
+            indentation(node) << rescue_args.loc.expression.source <<
+            "\n#{offset(node)}end"
+          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                            node.loc.expression.begin_pos,
+                                            node.loc.expression.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, correction)
           end
         end
+
+        private
+
+        def modifier?(node)
+          return false unless @modifier_locations.respond_to?(:include?)
+          @modifier_locations.include?(node.loc.keyword)
+        end
       end
     end
   end

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

@@ -20,6 +20,7 @@ module RuboCop
         def on_dstr(node)
           node.children.select { |n| n.type == :begin }.each do |begin_node|
             final_node = begin_node.children.last
+            next unless final_node
 
             interp = final_node.loc.expression
             interp_with_surrounding_space = range_with_surrounding_space(interp)

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of consistent method names
+      # from the String class.
+      class StringMethods < Cop
+        include MethodPreference
+
+        MSG = 'Prefer `%s` over `%s`.'
+
+        def on_send(node)
+          _receiver, method_name, *_args = *node
+          return unless preferred_methods[method_name]
+          add_offense(node, :selector,
+                      format(MSG,
+                             preferred_method(method_name),
+                             method_name)
+                     )
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              preferred_method(node.loc.selector.source))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -17,18 +17,20 @@ module RuboCop
         PROC_NODE = s(:send, s(:const, nil, :Proc), :new)
 
         def on_block(node)
-          block_send, block_args, block_body = *node
+          block_send_or_super, block_args, block_body = *node
 
-          _breceiver, bmethod_name, bargs = *block_send
+          if super?(block_send_or_super)
+            bmethod_name = :super
+          else
+            _breceiver, bmethod_name, _bargs = *block_send_or_super
+          end
 
           # TODO: Rails-specific handling that we should probably make
           # configurable - https://github.com/bbatsov/rubocop/issues/1485
           # we should ignore lambdas & procs
-          return if block_send == PROC_NODE
+          return if block_send_or_super == PROC_NODE
           return if [:lambda, :proc].include?(bmethod_name)
           return if ignored_method?(bmethod_name)
-          # File.open(file) { |f| f.readlines }
-          return if bargs
           return unless can_shorten?(block_args, block_body)
 
           _receiver, method_name, _args = *block_body
@@ -41,16 +43,52 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            _block_method, _block_args, block_body = *node
+            block_send_or_super, _block_args, block_body = *node
             _receiver, method_name, _args = *block_body
 
-            block_range =
-              Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                        node.loc.begin.begin_pos,
-                                        node.loc.end.end_pos)
+            if super?(block_send_or_super)
+              args = *block_send_or_super
+              autocorrect_method(corrector, node, args, method_name)
+            else
+              _breceiver, _bmethod_name, *args = *block_send_or_super
+              autocorrect_method(corrector, node, args, method_name)
+            end
+          end
+        end
 
-            corrector.replace(range_with_surrounding_space(block_range, :left),
-                              "(&:#{method_name})")
+        def autocorrect_method(corrector, node, args, method_name)
+          if args.empty?
+            autocorrect_no_args(corrector, node, method_name)
+          else
+            autocorrect_with_args(corrector, node, args, method_name)
+          end
+        end
+
+        def autocorrect_no_args(corrector, node, method_name)
+          corrector.replace(block_range_with_space(node), "(&:#{method_name})")
+        end
+
+        def autocorrect_with_args(corrector, node, args, method_name)
+          corrector.insert_after(args.last.loc.expression, ", &:#{method_name}")
+          corrector.remove(block_range_with_space(node))
+        end
+
+        def block_range_with_space(node)
+          block_range =
+            Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                      begin_pos_for_replacement(node),
+                                      node.loc.end.end_pos)
+          range_with_surrounding_space(block_range, :left)
+        end
+
+        def begin_pos_for_replacement(node)
+          block_send_or_super, _block_args, _block_body = *node
+          expr = block_send_or_super.loc.expression
+
+          if (paren_pos = (expr.source =~ /\(\s*\)$/))
+            expr.begin_pos + paren_pos
+          else
+            node.loc.begin.begin_pos
           end
         end
 
@@ -78,6 +116,10 @@ module RuboCop
 
           block_arg_name == receiver_name
         end
+
+        def super?(node)
+          [:super, :zsuper].include?(node.type)
+        end
       end
     end
   end

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

@@ -35,7 +35,7 @@ module RuboCop
           begin_pos = sb.source.length - whitespace_at_end.length
           autocorrect_range = Parser::Source::Range.new(sb, begin_pos,
                                                         sb.source.length)
-          begin_pos += "\n".length unless whitespace_at_end.length == 0
+          begin_pos += 1 unless whitespace_at_end.length == 0
           report_range = Parser::Source::Range.new(sb, begin_pos,
                                                    sb.source.length)
           add_offense(autocorrect_range, report_range,

data/lib/rubocop/cop/team.rb

@@ -97,8 +97,8 @@ module RuboCop
         file_errors.each do |cop, errors|
           errors.each do |e|
             handle_error(e,
-                         "An error occurred while #{cop.name}".color(:red) +
-                         " cop was inspecting #{file}.".color(:red))
+                         Rainbow("An error occurred while #{cop.name}" /
+                         " cop was inspecting #{file}.".red))
           end
         end
       end

data/lib/rubocop/cop/util.rb

@@ -186,8 +186,8 @@ module RuboCop
       end
 
       def begins_its_line?(range)
-        source_before_end = range.source_buffer.source[0...range.begin_pos]
-        source_before_end =~ /\n\s*\Z/
+        source_before_range = range.source_buffer.source[0...range.begin_pos]
+        source_before_range.rpartition("\n").last.strip.empty?
       end
 
       def within_node?(inner, outer)

data/lib/rubocop/cop/variable_force.rb

@@ -106,28 +106,28 @@ module RuboCop
       # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
       def dispatch_node(node)
         case node.type
-        when *ARGUMENT_DECLARATION_TYPES
-          process_variable_declaration(node)
         when VARIABLE_ASSIGNMENT_TYPE
           process_variable_assignment(node)
         when REGEXP_NAMED_CAPTURE_TYPE
           process_regexp_named_captures(node)
-        when *OPERATOR_ASSIGNMENT_TYPES
-          process_variable_operator_assignment(node)
         when MULTIPLE_ASSIGNMENT_TYPE
           process_variable_multiple_assignment(node)
         when VARIABLE_REFERENCE_TYPE
           process_variable_referencing(node)
-        when *LOOP_TYPES
-          process_loop(node)
         when RESCUE_TYPE
           process_rescue(node)
         when ZERO_ARITY_SUPER_TYPE
           process_zero_arity_super(node)
-        when *SCOPE_TYPES
-          process_scope(node)
         when SEND_TYPE
           process_send(node)
+        when *ARGUMENT_DECLARATION_TYPES
+          process_variable_declaration(node)
+        when *OPERATOR_ASSIGNMENT_TYPES
+          process_variable_operator_assignment(node)
+        when *LOOP_TYPES
+          process_loop(node)
+        when *SCOPE_TYPES
+          process_scope(node)
         end
       end
       # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
@@ -326,13 +326,13 @@ module RuboCop
           case node.type
           when :lvar
             referenced_variable_names_in_loop << node.children.first
+          when :lvasgn
+            assignment_nodes_in_loop << node
           when *OPERATOR_ASSIGNMENT_TYPES
             asgn_node = node.children.first
             if asgn_node.type == :lvasgn
               referenced_variable_names_in_loop << asgn_node.children.first
             end
-          when :lvasgn
-            assignment_nodes_in_loop << node
           end
         end
 

data/lib/rubocop/cop/variable_force/locatable.rb

@@ -80,9 +80,9 @@ module RuboCop
           case branch_point_node.type
           when :if                     then if_body_name
           when :case                   then case_body_name
-          when *LOGICAL_OPERATOR_TYPES then logical_operator_body_name
           when RESCUE_TYPE             then rescue_body_name
           when ENSURE_TYPE             then ensure_body_name
+          when *LOGICAL_OPERATOR_TYPES then logical_operator_body_name
           else fail InvalidBranchBodyError
           end
         rescue InvalidBranchBodyError
@@ -157,14 +157,14 @@ module RuboCop
           child_index = parent_node.children.index(child_node)
 
           case parent_node.type
-          when *BRANCH_TYPES
-            child_index != CONDITION_INDEX_OF_BRANCH_NODE
-          when *LOGICAL_OPERATOR_TYPES
-            child_index != LEFT_SIDE_INDEX_OF_LOGICAL_OPERATOR_NODE
           when RESCUE_TYPE
             true
           when ENSURE_TYPE
             child_index != ENSURE_INDEX_OF_ENSURE_NODE
+          when *BRANCH_TYPES
+            child_index != CONDITION_INDEX_OF_BRANCH_NODE
+          when *LOGICAL_OPERATOR_TYPES
+            child_index != LEFT_SIDE_INDEX_OF_LOGICAL_OPERATOR_NODE
           else
             false
           end

data/lib/rubocop/formatter/formatter_set.rb

@@ -52,6 +52,7 @@ module RuboCop
 
         offenses = offenses.sort.reject(&:disabled?)
         each { |f| f.file_finished(file, offenses) }
+        offenses
       end
 
       def add_formatter(formatter_type, output_path = nil)

data/lib/rubocop/options.rb

@@ -15,9 +15,16 @@ module RuboCop
 
     def parse(args)
       define_options(args).parse!(args)
+      # The --no-color CLI option sets `color: false` so we don't want the
+      # `no_color` key, which is created automatically.
+      @options.delete(:no_color)
 
       validate_compatibility
 
+      if @options[:stdin] && !args.one?
+        fail ArgumentError, '-s/--stdin requires exactly one path.'
+      end
+
       [@options, args]
     end
 
@@ -40,6 +47,7 @@ module RuboCop
       OptionParser.new do |opts|
         opts.banner = 'Usage: rubocop [options] [file1, file2, ...]'
 
+        add_list_options(opts)
         add_only_options(opts)
         add_configuration_options(opts, args)
         add_formatting_options(opts)
@@ -57,6 +65,9 @@ module RuboCop
          (@options[:only] & %w(Lint/UnneededDisable UnneededDisable)).any?
         fail ArgumentError, 'Lint/UnneededDisable can not be used with --only.'
       end
+      if @options.key?(:cache) && !%w(true false).include?(@options[:cache])
+        fail ArgumentError, '-C/--cache argument must be true or false'
+      end
       return unless (incompat = @options.keys & EXITING_OPTIONS).size > 1
       fail ArgumentError, "Incompatible cli options: #{incompat.inspect}"
     end
@@ -121,6 +132,7 @@ module RuboCop
 
     def add_boolean_flags(opts)
       option(opts, '-F', '--fail-fast')
+      option(opts, '-C', '--cache FLAG')
       option(opts, '-d', '--debug')
       option(opts, '-D', '--display-cop-names')
       option(opts, '-S', '--display-style-guide')
@@ -133,6 +145,11 @@ module RuboCop
 
       option(opts, '-v', '--version')
       option(opts, '-V', '--verbose-version')
+      option(opts, '-s', '--stdin') { @options[:stdin] = $stdin.read }
+    end
+
+    def add_list_options(opts)
+      option(opts, '-L', '--list-target-files')
     end
 
     # Sets a value in the @options hash, based on the given long option and its
@@ -222,15 +239,21 @@ module RuboCop
       fail_fast:           ['Inspect files in order of modification',
                             'time and stop after the first file',
                             'containing offenses.'],
+      cache:               ["Use result caching (FLAG=true) or don't",
+                            '(FLAG=false), default determined by',
+                            'configuration parameter AllCops: UseCache.'],
       debug:                'Display debug info.',
       display_cop_names:    'Display cop names in offense messages.',
       display_style_guide:  'Display style guide URLs in offense messages.',
       rails:                'Run extra Rails cops.',
       lint:                 'Run only lint cops.',
+      list_target_files:    'List all files RuboCop will inspect.',
       auto_correct:         'Auto-correct offenses.',
       no_color:             'Disable color output.',
       version:              'Display version.',
-      verbose_version:      'Display verbose version.'
+      verbose_version:      'Display verbose version.',
+      stdin:                ['Pipe source from STDIN.',
+                             'This is useful for editor integration.']
     }
   end
 end

data/lib/rubocop/result_cache.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+require 'digest/md5'
+require 'find'
+require 'tmpdir'
+
+module RuboCop
+  # Provides functionality for caching rubocop runs.
+  class ResultCache
+    # Include the user name in the path as a simple means of avoiding write
+    # collisions.
+    def initialize(file, options, config_store, cache_root = nil)
+      cache_root ||= ResultCache.cache_root(config_store)
+      @path = File.join(cache_root, rubocop_checksum, relevant_options(options),
+                        file_checksum(file, config_store))
+    end
+
+    def valid?
+      File.exist?(@path)
+    end
+
+    def load
+      Marshal.load(IO.read(@path))
+    end
+
+    def save(offenses, disabled_line_ranges, comments)
+      FileUtils.mkdir_p(File.dirname(@path))
+      preliminary_path = "#{@path}_#{rand(1_000_000_000)}"
+      File.open(preliminary_path, 'w') do |f|
+        # The Hash[x.sort] call is a trick that converts a Hash with a default
+        # block to a Hash without a default block. Thus making it possible to
+        # dump.
+        f.write(Marshal.dump([offenses, Hash[disabled_line_ranges.sort],
+                              comments]))
+      end
+      # The preliminary path is used so that if there are multiple RuboCop
+      # processes trying to save data for the same inspected file
+      # simultaneously, the only problem we run in to is a competition who gets
+      # to write to the final file. The contents are the same, so no corruption
+      # of data should occur.
+      FileUtils.mv(preliminary_path, @path)
+    end
+
+    # Remove old files so that the cache doesn't grow too big. When the
+    # threshold MaxFilesInCache has been exceeded, the oldest 50% all the files
+    # in the cache are removed. The reason for removing so much is that
+    # cleaning should be done relatively seldom, since there is a slight risk
+    # that some other RuboCop process was just about to read the file, when
+    # there's parallel execution and the cache is shared.
+    def self.cleanup(config_store, verbose, cache_root = nil)
+      return if inhibit_cleanup # OPTIMIZE: For faster testing
+      cache_root ||= cache_root(config_store)
+      return unless File.exist?(cache_root)
+
+      files, dirs = Find.find(cache_root).partition { |path| File.file?(path) }
+      if files.length > config_store.for('.')['AllCops']['MaxFilesInCache'] &&
+         files.length > 1
+        # Add 1 to half the number of files, so that we remove the file if
+        # there's only 1 left.
+        remove_count = 1 + files.length / 2
+        if verbose
+          puts "Removing the #{remove_count} oldest files from #{cache_root}"
+        end
+        sorted = files.sort_by { |path| File.mtime(path) }
+        begin
+          sorted[0, remove_count].each { |path| File.delete(path) }
+          dirs.each { |dir| Dir.rmdir(dir) if Dir["#{dir}/*"].empty? }
+        rescue Errno::ENOENT
+          # This can happen if parallel RuboCop invocations try to remove the
+          # same files. No problem.
+          puts $ERROR_INFO if verbose
+        end
+      end
+    end
+
+    private
+
+    def self.cache_root(config_store)
+      root = config_store.for('.')['AllCops']['CacheRootDirectory']
+      root = Dir.tmpdir if root == '/tmp'
+      File.join(root, 'rubocop_cache')
+    end
+
+    def file_checksum(file, config_store)
+      Digest::MD5.hexdigest(Dir.pwd + file + IO.read(file) +
+                            config_store.for(file).to_s)
+    rescue Errno::ENOENT
+      # Spurious files that come and go should not cause a crash, at least not
+      # here.
+      '_'
+    end
+
+    class << self
+      attr_accessor :source_checksum, :inhibit_cleanup
+    end
+
+    # The checksum of the rubocop program running the inspection.
+    def rubocop_checksum
+      ResultCache.source_checksum ||=
+        begin
+          lib_root = File.join(File.dirname(__FILE__), '..')
+          bin_root = File.join(lib_root, '..', 'bin')
+          source = Find.find(lib_root, bin_root).sort.map do |path|
+            IO.read(path) if File.file?(path)
+          end
+          Digest::MD5.hexdigest(source.join)
+        end
+    end
+
+    NON_CHANGING = [:color, :format, :formatters, :out, :debug, :fail_level,
+                    :cache, :fail_fast]
+
+    # Return the options given at invocation, minus the ones that have no
+    # effect on which offenses and disabled line ranges are found, and thus
+    # don't affect caching.
+    def relevant_options(options)
+      options = options.reject { |key, _| NON_CHANGING.include?(key) }
+      options.to_s.gsub(/[^a-z]+/i, '_')
+    end
+  end
+end