rubocop 0.35.1 → 0.36.0

data/lib/rubocop/cop/team.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
     class Team
       attr_reader :errors, :warnings, :updated_source_file
 
-      alias_method :updated_source_file?, :updated_source_file
+      alias updated_source_file? updated_source_file
 
       def initialize(cop_classes, config, options = nil)
         @cop_classes = cop_classes
@@ -14,6 +15,8 @@ module RuboCop
         @options = options || { auto_correct: false, debug: false }
         @errors = []
         @warnings = []
+
+        validate_config
       end
 
       def autocorrect?
@@ -38,9 +41,8 @@ module RuboCop
       end
 
       def cops
-        @cops ||= @cop_classes.each_with_object([]) do |cop_class, instances|
-          next unless cop_enabled?(cop_class)
-          instances << cop_class.new(@config, @options)
+        @cops ||= @cop_classes.select { |c| cop_enabled?(c) }.map do |cop_class|
+          cop_class.new(@config, @options)
         end
       end
 
@@ -67,8 +69,13 @@ module RuboCop
 
         return if new_source == buffer.source
 
-        filename = buffer.name
-        File.open(filename, 'w') { |f| f.write(new_source) }
+        if @options[:stdin]
+          # holds source read in from stdin, when --stdin option is used
+          @options[:stdin] = new_source
+        else
+          filename = buffer.name
+          File.open(filename, 'wb') { |f| f.write(new_source) }
+        end
         @updated_source_file = true
       end
 
@@ -76,17 +83,10 @@ module RuboCop
       # re-running of auto-corrections will make sure that the full set of
       # auto-corrections is tried again after this method has finished.
       def autocorrect_one_cop(buffer, cops)
-        cop_with_corrections = cops.find do |cop|
-          cop.relevant_file?(buffer.name) && cop.corrections.any?
-        end
+        cop_with_corrections = cops.find { |cop| cop.corrections.any? }
+
         if cop_with_corrections
           corrections = cop_with_corrections.corrections
-          # Be extra careful if there are tabs in the source and just correct
-          # one offense, because inserting or removing space next to a tab has
-          # special implications, and existing ranges can't be used after such
-          # a change.
-          corrections = [corrections.first] if buffer.source =~ /\t/
-
           corrector = Corrector.new(buffer, corrections)
           corrector.rewrite
         else
@@ -94,6 +94,12 @@ module RuboCop
         end
       end
 
+      def validate_config
+        cops.each do |cop|
+          cop.validate_config if cop.respond_to?(:validate_config)
+        end
+      end
+
       def process_commissioner_errors(file, file_errors)
         file_errors.each do |cop, errors|
           errors.each do |e|

data/lib/rubocop/cop/util.rb

@@ -1,28 +1,42 @@
 # encoding: utf-8
-
+# frozen_string_literal: true
 # rubocop:disable Metrics/ModuleLength
+
 module RuboCop
   module Cop
     # This module contains a collection of useful utility methods.
     module Util
       include PathUtil
-      extend AST::Sexp
-
-      PROC_NEW_NODE = s(:send, s(:const, nil, :Proc), :new)
-      EQUALS_ASGN_NODES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn, :masgn]
-      SHORTHAND_ASGN_NODES = [:op_asgn, :or_asgn, :and_asgn]
-      ASGN_NODES = EQUALS_ASGN_NODES + SHORTHAND_ASGN_NODES
+      extend RuboCop::Sexp
 
-      LITERALS = [:str, :dstr, :int, :float, :sym, :dsym, :array,
-                  :hash, :regexp, :nil, :true, :false]
-      BASIC_LITERALS = LITERALS - [:dstr, :dsym, :array, :hash]
+      EQUALS_ASGN_NODES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn,
+                           :casgn, :masgn].freeze
+      SHORTHAND_ASGN_NODES = [:op_asgn, :or_asgn, :and_asgn].freeze
+      ASGN_NODES = (EQUALS_ASGN_NODES + SHORTHAND_ASGN_NODES).freeze
 
       # http://phrogz.net/programmingruby/language.html#table_18.4
       # Backtick is added last just to help editors parse this code.
       OPERATOR_METHODS = %w(
         | ^ & <=> == === =~ > >= < <= << >>
         + - * / % ** ~ +@ -@ [] []= ! != !~
-      ).map(&:to_sym) + [:'`']
+      ).map(&:to_sym).push(:'`').freeze
+
+      STRING_ESCAPES = {
+        '\a' => "\a", '\b' => "\b", '\e' => "\e", '\f' => "\f", '\n' => "\n",
+        '\r' => "\r", '\s' => ' ',  '\t' => "\t", '\v' => "\v", "\\\n" => ''
+      }.freeze
+      STRING_ESCAPE_REGEX = /\\(?:
+                              [abefnrstv\n]    |   # simple escapes (above)
+                              \d{1,3}          |   # octal byte escape
+                              x\d{1,2}         |   # hex byte escape
+                              u[0-9a-fA-F]{4}  |   # unicode char escape
+                              u\{[^}]*\}       |   # extended unicode escape
+                              .                    # any other escaped char
+                            )/x
+
+      # Match literal regex characters, not including anchors, character
+      # classes, alternatives, groups, repetitions, references, etc
+      LITERAL_REGEX = /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGkwWszZS0-9]/
 
       module_function
 
@@ -33,12 +47,11 @@ module RuboCop
       def strip_quotes(str)
         if str[0] == '"' || str[0] == "'"
           str[0] = ''
-          str[-1] = ''
         else
           # we're dealing with %q or %Q
           str[0, 3] = ''
-          str[-1] = ''
         end
+        str[-1] = ''
 
         str
       end
@@ -56,7 +69,7 @@ module RuboCop
                        when Parser::Source::Range
                          arg
                        when Parser::AST::Node
-                         arg.loc.expression
+                         arg.source_range
                        else
                          fail ArgumentError, "Invalid argument #{arg}"
                        end
@@ -64,65 +77,20 @@ module RuboCop
         source_range.begin.line..source_range.end.line
       end
 
-      def const_name(node)
-        return nil if node.nil? || node.type != :const
-
-        const_names = []
-        const_node = node
-
-        loop do
-          namespace_node, name = *const_node
-          const_names << name
-          break unless namespace_node
-          break unless namespace_node.is_a?(Parser::AST::Node)
-          break if namespace_node.type == :cbase
-          const_node = namespace_node
-        end
-
-        const_names.reverse.join('::')
-      end
-
-      def command?(name, node)
-        return unless node.type == :send
-
-        receiver, method_name, _args = *node
-
-        # commands have no explicit receiver
-        !receiver && method_name == name
-      end
-
-      def lambda?(node)
-        fail 'Not a block node' unless node.type == :block
-
-        send_node, _block_args, _block_body = *node
-
-        command?(:lambda, send_node)
-      end
-
-      def proc?(node)
-        fail 'Not a block node' unless node.type == :block
-
-        send_node, _block_args, _block_body = *node
-
-        command?(:proc, send_node) || send_node == PROC_NEW_NODE
-      end
-
-      def lambda_or_proc?(node)
-        lambda?(node) || proc?(node)
-      end
-
       def parentheses?(node)
-        node.loc.respond_to?(:end) && node.loc.end
+        node.loc.respond_to?(:end) && node.loc.end &&
+          node.loc.end.is?(')'.freeze)
       end
 
-      def on_node(syms, sexp, excludes = [])
-        yield sexp if Array(syms).include?(sexp.type)
+      def on_node(syms, sexp, excludes = [], &block)
+        return to_enum(:on_node, syms, sexp, excludes) unless block_given?
 
+        yield sexp if Array(syms).include?(sexp.type)
         return if Array(excludes).include?(sexp.type)
 
         sexp.children.each do |elem|
           next unless elem.is_a?(Parser::AST::Node)
-          on_node(syms, elem, excludes) { |s| yield s }
+          on_node(syms, elem, excludes, &block)
         end
       end
 
@@ -191,13 +159,17 @@ module RuboCop
       end
 
       def begins_its_line?(range)
-        source_before_range = range.source_buffer.source[0...range.begin_pos]
-        source_before_range.rpartition("\n").last.strip.empty?
+        (range.source_line =~ /\S/) == range.column
+      end
+
+      def ends_its_line?(range)
+        line = range.source_buffer.source_line(range.last_line)
+        (line =~ /\s*\z/) == range.last_column
       end
 
       def within_node?(inner, outer)
-        o = outer.loc.expression
-        i = inner.loc.expression
+        o = outer.is_a?(Node) ? outer.source_range : outer
+        i = inner.is_a?(Node) ? inner.source_range : inner
         i.begin_pos >= o.begin_pos && i.end_pos <= o.end_pos
       end
 
@@ -226,6 +198,67 @@ module RuboCop
         size = 0 if size < 0
         size
       end
+
+      # If converting a string to Ruby string literal source code, must
+      # double quotes be used?
+      def double_quotes_required?(string)
+        # Double quotes are required for strings which either:
+        # - Contain single quotes
+        # - Contain non-printable characters, which must use an escape
+
+        # Regex matches IF there is a ' or there is a \\ in the string that is
+        # not preceded/followed by another \\ (e.g. "\\x34") but not "\\\\".
+        string.inspect =~ /'|(?<! \\) \\{2}* \\ (?![\\"])/x
+      end
+
+      # If double quoted string literals are found in Ruby code, and they are
+      # not the preferred style, should they be flagged?
+      def double_quotes_acceptable?(string)
+        # If a string literal contains hard-to-type characters which would
+        # not appear on a "normal" keyboard, then double-quotes are acceptable
+        double_quotes_required?(string) ||
+          string.codepoints.any? { |cp| cp < 32 || cp > 126 }
+      end
+
+      def to_string_literal(string)
+        if double_quotes_required?(string)
+          string.inspect
+        else
+          "'#{string.gsub('\\') { '\\\\' }}'"
+        end
+      end
+
+      def to_symbol_literal(string)
+        if string =~ /\s/ || double_quotes_required?(string)
+          ":#{to_string_literal(string)}"
+        else
+          ":#{string}"
+        end
+      end
+
+      # Take a string with embedded escapes, and convert the escapes as the Ruby
+      # interpreter would when reading a double-quoted string literal.
+      # For example, "\\n" will be converted to "\n".
+      def interpret_string_escapes(string)
+        # We currently don't handle \cx, \C-x, and \M-x
+        string.gsub(STRING_ESCAPE_REGEX) do |escape|
+          STRING_ESCAPES[escape] || begin
+            if escape[1] == 'x'
+              [escape[2..-1].hex].pack('C')
+            elsif escape[1] == 'u'
+              if escape[2] == '{'
+                escape[3..-1].split(/\s+/).map(&:hex).pack('U')
+              else
+                [escape[2..-1].hex].pack('U')
+              end
+            elsif escape[1] =~ /\d/ # octal escape
+              [escape[1..-1].to_i(8)].pack('C')
+            else
+              escape[1] # literal escaped char, like \\
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/variable_force.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -59,7 +60,7 @@ module RuboCop
         if root_node.begin_type?
           root_node
         else
-          Astrolabe::Node.new(:begin, [root_node])
+          Node.new(:begin, [root_node])
         end
       end
 

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -11,7 +12,7 @@ module RuboCop
         REFERENCE_PENETRABLE_BRANCH_TYPES = %w(rescue_main ensure_main).freeze
 
         attr_reader :node, :variable, :referenced
-        alias_method :referenced?, :referenced
+        alias referenced? referenced
 
         def initialize(node, variable)
           unless VARIABLE_ASSIGNMENT_TYPES.include?(node.type)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -13,7 +14,7 @@ module RuboCop
           class:  0..1,
           sclass: 0..0,
           block:  0..0
-        }
+        }.freeze
 
         attr_reader :node, :variables
 

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -12,7 +13,7 @@ module RuboCop
 
         attr_reader :name, :declaration_node, :scope,
                     :assignments, :references, :captured_by_block
-        alias_method :captured_by_block?, :captured_by_block
+        alias captured_by_block? captured_by_block
 
         def initialize(name, declaration_node, scope)
           unless VARIABLE_DECLARATION_TYPES.include?(declaration_node.type)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -58,7 +59,7 @@ module RuboCop
 
           unless variable
             fail "Assigning to undeclared local variable \"#{name}\" " \
-                 "at #{node.loc.expression}, #{node.inspect}"
+                 "at #{node.source_range}, #{node.inspect}"
           end
 
           variable.assign(node)

data/lib/rubocop/error.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  # An Error exception is different from an Offense with severity 'error'
+  # When this exception is raised, it means that RuboCop is unable to perform
+  # a requested action (probably due to misconfiguration) and must stop
+  # immediately, rather than carrying on
+  class Error < StandardError; end
+
+  class ValidationError < Error; end
+end

data/lib/rubocop/formatter/base_formatter.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 # rubocop:disable Metrics/LineLength
 
@@ -53,12 +54,20 @@ module RuboCop
       # @see #initialize
       attr_reader :output
 
+      # @api public
+      #
+      # @!attribute [r] options
+      #
+      # @return [Hash]
+      attr_reader :options
+
       # @api public
       #
       # @param output [IO]
       #   `$stdout` or opened file
-      def initialize(output)
+      def initialize(output, options = {})
         @output = output
+        @options = options
       end
 
       # @api public