rubocop 0.31.0 → 0.35.0

data/lib/rubocop/cop/mixin/configurable_enforced_style.rb

@@ -5,28 +5,75 @@ module RuboCop
     # Handles `EnforcedStyle` configuration parameters.
     module ConfigurableEnforcedStyle
       def opposite_style_detected
-        self.config_to_allow_offenses ||=
-          { parameter_name => alternative_style.to_s }
-        both_styles_detected if config_to_allow_offenses['Enabled']
+        style_detected(alternative_style)
       end
 
       def correct_style_detected
-        # Enabled:true indicates, later when the opposite style is detected,
-        # that the correct style is used somewhere.
-        self.config_to_allow_offenses ||= { 'Enabled' => true }
-        both_styles_detected if config_to_allow_offenses[parameter_name]
+        style_detected(style)
       end
 
-      def both_styles_detected
-        # Both correct and opposite styles exist.
-        self.config_to_allow_offenses = { 'Enabled' => false }
+      def unexpected_style_detected(unexpected)
+        style_detected(unexpected)
+      end
+
+      def ambiguous_style_detected(*possibilities)
+        style_detected(possibilities)
       end
 
-      def unrecognized_style_detected
-        # All we can do is to disable.
+      def style_detected(detected)
+        # `detected` can be a single style, or an Array of possible styles
+        # (if there is more than one which matches the observed code)
+
+        return if no_acceptable_style?
+
+        if detected.is_a?(Array)
+          detected.map!(&:to_s)
+        else
+          detected = detected.to_s
+        end
+
+        if !detected_style # we haven't observed any specific style yet
+          self.detected_style = detected
+        elsif detected_style.is_a?(Array)
+          self.detected_style &= [*detected]
+        elsif detected.is_a?(Array)
+          no_acceptable_style! unless detected.include?(detected_style)
+        else
+          no_acceptable_style! unless detected_style == detected
+        end
+      end
+
+      def no_acceptable_style?
+        config_to_allow_offenses['Enabled'] == false
+      end
+
+      def no_acceptable_style!
         self.config_to_allow_offenses = { 'Enabled' => false }
       end
 
+      def detected_style
+        config_to_allow_offenses[parameter_name]
+      end
+
+      def detected_style=(style)
+        if style.nil?
+          no_acceptable_style!
+        elsif style.is_a?(Array)
+          if style.empty?
+            no_acceptable_style!
+          elsif style.one?
+            config_to_allow_offenses[parameter_name] = style[0]
+          else
+            config_to_allow_offenses[parameter_name] = style
+          end
+        else
+          config_to_allow_offenses[parameter_name] = style
+        end
+      end
+
+      alias_method :conflicting_styles_detected, :no_acceptable_style!
+      alias_method :unrecognized_style_detected, :no_acceptable_style!
+
       def style
         s = cop_config[parameter_name]
         if cop_config['SupportedStyles'].include?(s)

data/lib/rubocop/cop/mixin/configurable_max.rb

@@ -6,7 +6,7 @@ module RuboCop
     # appropriate value with --auto-gen-config.
     module ConfigurableMax
       def max=(value)
-        cfg = self.config_to_allow_offenses ||= {}
+        cfg = config_to_allow_offenses
         value = [cfg[parameter_name], value].max if cfg[parameter_name]
         cfg[parameter_name] = value
       end

data/lib/rubocop/cop/mixin/configurable_naming.rb

@@ -13,7 +13,7 @@ module RuboCop
       def check_name(node, name, name_range)
         return if operator?(name)
 
-        if valid_name?(name)
+        if valid_name?(node, name)
           correct_style_detected
         else
           add_offense(node, name_range, message(style)) do
@@ -22,9 +22,20 @@ module RuboCop
         end
       end
 
-      def valid_name?(name)
+      def valid_name?(node, name)
         pattern = (style == :snake_case ? SNAKE_CASE : CAMEL_CASE)
-        name.match(pattern)
+        name.match(pattern) || class_emitter_method?(node, name)
+      end
+
+      # A class emitter method is a singleton method in a class/module, where
+      # the method has the same name as a class defined in the class/module.
+      def class_emitter_method?(node, name)
+        return false unless node.defs_type?
+        return false unless node.parent
+
+        node.parent.children.compact.any? do |c|
+          c.class_type? && c.loc.name.is?(name.to_s)
+        end
       end
     end
   end

data/lib/rubocop/cop/mixin/empty_lines_around_body.rb

@@ -34,9 +34,7 @@ module RuboCop
         def check_source(start_line, end_line)
           case style
           when :no_empty_lines
-            check_both(start_line, end_line, MSG_EXTRA) do |line|
-              line.empty?
-            end
+            check_both(start_line, end_line, MSG_EXTRA, &:empty?)
           when :empty_lines
             check_both(start_line, end_line, MSG_MISSING) do |line|
               !line.empty?

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -6,7 +6,7 @@ module RuboCop
     module EndKeywordAlignment
       include ConfigurableEnforcedStyle
 
-      MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d'
+      MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'
 
       private
 
@@ -38,6 +38,15 @@ module RuboCop
         'AlignWith'
       end
 
+      def variable_alignment?(whole_expression, rhs, end_alignment_style)
+        end_alignment_style == :variable &&
+          !line_break_before_keyword?(whole_expression, rhs)
+      end
+
+      def line_break_before_keyword?(whole_expression, rhs)
+        rhs.loc.line > whole_expression.line
+      end
+
       def align(node, alignment_node)
         source_buffer = node.loc.expression.source_buffer
         begin_pos = node.loc.end.begin_pos

data/lib/rubocop/cop/mixin/first_element_line_break.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    # Common functionality for checking for a line break before the first
+    # element in a multi-line collection.
+    module FirstElementLineBreak
+      def autocorrect(node)
+        ->(corrector) { corrector.insert_before(node.loc.expression, "\n") }
+      end
+
+      private
+
+      def check_method_line_break(node, children)
+        return if children.empty?
+
+        return unless method_uses_parens?(node, children.first)
+
+        check_children_line_break(node, children)
+      end
+
+      def method_uses_parens?(node, limit)
+        source = node.loc.expression.source_line[0...limit.loc.column]
+        source =~ /\s*\(\s*$/
+      end
+
+      def check_children_line_break(node, children, start = node)
+        return if children.size < 2
+
+        line = start.loc.line
+        min = children.min_by { |n| n.loc.first_line }
+        return if line != min.loc.first_line
+
+        max = children.max_by { |n| n.loc.last_line }
+        return if line == max.loc.last_line
+
+        add_offense(min, :expression, self.class::MSG)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/if_node.rb

@@ -22,6 +22,16 @@ module RuboCop
       def if_else?(node)
         node.loc.respond_to?(:else) && node.loc.else
       end
+
+      def if_node_parts(node)
+        case node.loc.keyword.source
+        when 'if', 'elsif' then condition, body, else_clause = *node
+        when 'unless'      then condition, else_clause, body = *node
+        else                    condition, body = *node
+        end
+
+        [condition, body, else_clause]
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/method_preference.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    # Common code for cops that deal with preferred methods.
+    module MethodPreference
+      def preferred_method(method)
+        preferred_methods[method.to_sym]
+      end
+
+      def preferred_methods
+        @preferred_methods ||=
+          begin
+            # Make sure default configuration 'foo' => 'bar' is removed from
+            # the total configuration if there is a 'bar' => 'foo' override.
+            default = default_cop_config['PreferredMethods']
+            merged = cop_config['PreferredMethods']
+            overrides = merged.values - default.values
+            merged.reject { |key, _| overrides.include?(key) }.symbolize_keys
+          end
+      end
+
+      def default_cop_config
+        ConfigLoader.default_configuration[cop_name]
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/negative_conditional.rb

@@ -8,7 +8,7 @@ module RuboCop
       def check_negative_conditional(node)
         condition, _body, _rest = *node
 
-        # Look at last expression of contents if there's a parenthesis
+        # Look at last expression of contents if there are parentheses
         # around condition.
         condition = condition.children.last while condition.type == :begin
         return unless condition.type == :send

data/lib/rubocop/cop/mixin/on_method_def.rb

@@ -19,12 +19,11 @@ module RuboCop
       # Returns true for constructs such as
       # private def my_method
       # which are allowed in Ruby 2.1 and later.
-      def visibility_and_def_on_same_line?(receiver, method_name, args)
+      def modifier_and_def_on_same_line?(receiver, method_name, args)
         !receiver &&
-          [:public, :protected, :private,
-           :private_class_method, :public_class_method,
-           :module_function].include?(method_name) &&
-          args.size == 1 && [:def, :defs].include?(args.first.type)
+          method_name != :def &&
+          args.size == 1 &&
+          [:def, :defs].include?(args.first.type)
       end
     end
   end

data/lib/rubocop/cop/mixin/safe_assignment.rb

@@ -6,21 +6,10 @@ module RuboCop
     # putting parentheses around an assignment to indicate "I know I'm using an
     # assignment as a condition. It's not a mistake."
     module SafeAssignment
-      def safe_assignment?(node)
-        return false unless node.type == :begin
-        return false unless node.children.size == 1
+      extend NodePattern::Macros
 
-        child = node.children.first
-        case child.type
-        when *Util::EQUALS_ASGN_NODES
-          true
-        when :send
-          _receiver, method_name, _args = *child
-          method_name.to_s.end_with?('=')
-        else
-          false
-        end
-      end
+      def_node_matcher :safe_assignment?,
+                       '(begin {equals_asgn? asgn_method_call?})'
 
       def safe_assignment_allowed?
         cop_config['AllowSafeAssignment']

data/lib/rubocop/cop/mixin/space_after_punctuation.rb

@@ -11,12 +11,19 @@ module RuboCop
         processed_source.tokens.each_cons(2) do |t1, t2|
           next unless kind(t1) && t1.pos.line == t2.pos.line &&
                       t2.pos.column == t1.pos.column + offset &&
-                      ![:tRPAREN, :tRBRACK, :tPIPE].include?(t2.type)
+                      ![:tRPAREN, :tRBRACK, :tPIPE].include?(t2.type) &&
+                      !(t2.type == :tRCURLY && space_forbidden_before_rcurly?)
 
           add_offense(t1, t1.pos, format(MSG, kind(t1)))
         end
       end
 
+      def space_forbidden_before_rcurly?
+        cfg = config.for_cop('Style/SpaceInsideBlockBraces')
+        style = cfg['Enabled'] ? cfg['EnforcedStyle'] : 'space'
+        style == 'no_space'
+      end
+
       # The normal offset, i.e., the distance from the punctuation
       # token where a space should be, is 1.
       def offset

data/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -10,7 +10,8 @@ module RuboCop
       def investigate(processed_source)
         processed_source.tokens.each_cons(2) do |t1, t2|
           next unless kind(t2) && t1.pos.line == t2.pos.line &&
-                      t2.pos.begin_pos > t1.pos.end_pos
+                      t2.pos.begin_pos > t1.pos.end_pos &&
+                      !(t1.type == :tLCURLY && space_required_after_lcurly?)
           buffer = processed_source.buffer
           pos_before_punctuation = Parser::Source::Range.new(buffer,
                                                              t1.pos.end_pos,
@@ -22,6 +23,12 @@ module RuboCop
         end
       end
 
+      def space_required_after_lcurly?
+        cfg = config.for_cop('Style/SpaceInsideBlockBraces')
+        style = cfg['Enabled'] ? cfg['EnforcedStyle'] : 'space'
+        style == 'space'
+      end
+
       def autocorrect(pos_before_punctuation)
         ->(corrector) { corrector.remove(pos_before_punctuation) }
       end

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -7,13 +7,10 @@ module RuboCop
       include IfNode
 
       def fit_within_line_as_modifier_form?(node)
-        case node.loc.keyword.source
-        when 'if'     then cond, body, _else = *node
-        when 'unless' then cond, _else, body = *node
-        else               cond, body = *node
-        end
+        cond, body, _else = if_node_parts(node)
 
         return false if length(node) > 3
+        return false if body && body.begin_type? # multiple statements
 
         body_length = body_length(body)
 
@@ -33,7 +30,7 @@ module RuboCop
       end
 
       def max_line_length
-        cop_config && cop_config['MaxLineLength'] ||
+        cop_config['MaxLineLength'] ||
           config.for_cop('Metrics/LineLength')['Max']
       end
 
@@ -58,7 +55,7 @@ module RuboCop
       end
 
       def comment_lines
-        @comment_lines ||= processed_source.comments.map(&:location).map(&:line)
+        @comment_lines ||= processed_source.comments.map { |c| c.location.line }
       end
     end
   end

data/lib/rubocop/cop/mixin/string_help.rb

@@ -31,7 +31,7 @@ module RuboCop
       def inside_interpolation?(node)
         # A :begin node inside a :dstr node is an interpolation.
         begin_found = false
-        node.each_ancestor.find do |a|
+        node.each_ancestor.any? do |a|
           begin_found = true if a.type == :begin
           begin_found && a.type == :dstr
         end

data/lib/rubocop/cop/mixin/string_literals_help.rb

@@ -12,7 +12,7 @@ module RuboCop
         if style == :single_quotes
           src !~ /'/ && src !~ StringHelp::ESCAPED_CHAR_REGEXP
         else
-          src !~ /" | \\/x
+          src !~ /" | \\ | \#/x
         end
       end
 

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

@@ -17,13 +17,13 @@ module RuboCop
 
       def index_of_first_token(node)
         b = node.loc.expression.begin
-        token_table[[b.line, b.column]]
+        token_table[b.line][b.column]
       end
 
       def index_of_last_token(node)
         e = node.loc.expression.end
-        (0...e.column).to_a.reverse.find do |c|
-          ix = token_table[[e.line, c]]
+        (0...e.column).to_a.reverse_each do |c|
+          ix = token_table[e.line][c]
           return ix if ix
         end
       end
@@ -32,7 +32,8 @@ module RuboCop
         @token_table ||= begin
           table = {}
           @processed_source.tokens.each_with_index do |t, ix|
-            table[[t.pos.line, t.pos.column]] = ix
+            table[t.pos.line] ||= {}
+            table[t.pos.line][t.pos.column] = ix
           end
           table
         end

data/lib/rubocop/cop/offense.rb

@@ -56,16 +56,29 @@ module RuboCop
       #
       # @return [Boolean]
       #   whether this offense is automatically corrected.
-      attr_reader :corrected
+      def corrected
+        @status == :unsupported ? nil : @status == :corrected
+      end
       alias_method :corrected?, :corrected
 
+      # @api public
+      #
+      # @!attribute [r] disabled?
+      #
+      # @return [Boolean]
+      #   whether this offense was locally disabled where it occurred
+      def disabled?
+        @status == :disabled
+      end
+
       # @api private
-      def initialize(severity, location, message, cop_name, corrected = false)
+      def initialize(severity, location, message, cop_name,
+                     status = :uncorrected)
         @severity = RuboCop::Cop::Severity.new(severity)
         @location = location
         @message = message.freeze
         @cop_name = cop_name.freeze
-        @corrected = corrected
+        @status = status
         freeze
       end
 

data/lib/rubocop/cop/performance/case_when_splat.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Performance
+      # Place `when` conditions that use splat at the end
+      # of the list of `when` branches.
+      #
+      # Ruby has to allocate memory for the splat expansion every time
+      # that the `case` `when` statement is run. Since Ruby does not support
+      # fall through inside of `case` `when`, like some other languages do,
+      # the order of the `when` branches does not matter. By placing any
+      # splat expansions at the end of the list of `when` branches we will
+      # reduce the number of times that memory has to be allocated for
+      # the expansion.
+      #
+      # This is not a guaranteed performance improvement. If the data being
+      # processed by the `case` condition is normalized in a manner that favors
+      # hitting a condition in the splat expansion, it is possible that
+      # moving the splat condition to the end will use more memory,
+      # and run slightly slower.
+      #
+      # @example
+      #   # bad
+      #   case foo
+      #   when *condition
+      #     bar
+      #   when baz
+      #     foobar
+      #   end
+      #
+      #   case foo
+      #   when *[1, 2, 3, 4]
+      #     bar
+      #   when 5
+      #     baz
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when baz
+      #     foobar
+      #   when *condition
+      #     bar
+      #   end
+      #
+      #   case foo
+      #   when 1, 2, 3, 4
+      #     bar
+      #   when 5
+      #     baz
+      #   end
+      class CaseWhenSplat < Cop
+        include AutocorrectAlignment
+
+        MSG = 'Place `when` conditions with a splat ' \
+              'at the end of the `when` branches.'.freeze
+        ARRAY_MSG = 'Do not expand array literals in `when` conditions.'.freeze
+        OPEN_BRACKET = '['.freeze
+        PERCENT_W = '%w'.freeze
+        PERCENT_CAPITAL_W = '%W'.freeze
+        PERCENT_I = '%i'.freeze
+        PERCENT_CAPITAL_I = '%I'.freeze
+
+        def on_case(node)
+          _case_branch, *when_branches, _else_branch = *node
+          when_conditions =
+            when_branches.each_with_object([]) do |branch, conditions|
+              condition, = *branch
+              conditions << condition
+            end
+
+          splat_offenses(when_conditions).reverse_each do |condition|
+            range = condition.parent.loc.keyword.join(condition.loc.expression)
+            variable, = *condition
+            message = variable.array_type? ? ARRAY_MSG : MSG
+            add_offense(condition.parent, range, message)
+          end
+        end
+
+        def autocorrect(node)
+          condition, = *node
+          variable, = *condition
+          if variable.array_type?
+            correct_array_literal(condition, variable)
+          else
+            reorder_splat_condition(node)
+          end
+        end
+
+        private
+
+        def splat_offenses(when_conditions)
+          found_non_splat = false
+          when_conditions.reverse.each_with_object([]) do |condition, result|
+            found_non_splat ||= true if error_condition?(condition)
+
+            next unless condition.splat_type?
+            result << condition if found_non_splat
+          end
+        end
+
+        def error_condition?(condition)
+          variable, = *condition
+
+          (condition.splat_type? && variable.array_type?) ||
+            !condition.splat_type?
+        end
+
+        def correct_array_literal(condition, variable)
+          lambda do |corrector|
+            array_start = variable.loc.begin.source
+
+            if array_start.start_with?(OPEN_BRACKET)
+              corrector.remove(condition.loc.operator)
+              corrector.remove(variable.loc.begin)
+              corrector.remove(variable.loc.end)
+            else
+              corrector.replace(condition.loc.expression,
+                                expand_percent_array(variable))
+            end
+          end
+        end
+
+        def reorder_splat_condition(node)
+          _case_branch, *when_branches, _else_branch = *node.parent
+          current_index = when_branches.index { |branch| branch == node }
+          next_branch = when_branches[current_index + 1]
+          correction = "\n#{offset(node)}#{node.loc.expression.source}"
+          range =
+            Parser::Source::Range.new(node.parent,
+                                      node.loc.expression.begin_pos,
+                                      next_branch.loc.expression.begin_pos)
+
+          lambda do |corrector|
+            corrector.remove(range)
+            corrector.insert_after(when_branches.last.loc.expression,
+                                   correction)
+          end
+        end
+
+        def expand_percent_array(array)
+          array_start = array.loc.begin.source
+          elements = *array
+          elements = elements.map { |e| e.loc.expression.source }
+
+          if array_start.start_with?(PERCENT_W)
+            "'#{elements.join("', '")}'"
+          elsif array_start.start_with?(PERCENT_CAPITAL_W)
+            %("#{elements.join('", "')}")
+          elsif array_start.start_with?(PERCENT_I)
+            ":#{elements.join(', :')}"
+          elsif array_start.start_with?(PERCENT_CAPITAL_I)
+            %(:"#{elements.join('", :"')}")
+          end
+        end
+      end
+    end
+  end
+end