rubocop 0.31.0 → 0.35.0

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

@@ -23,54 +23,60 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include MinBodyLength
 
-        MSG = 'Use `next` to skip iteration.'
-        ENUMERATORS = [:collect, :detect, :downto, :each, :find, :find_all,
-                       :inject, :loop, :map!, :map, :reduce, :reverse_each,
-                       :select, :times, :upto]
+        MSG = 'Use `next` to skip iteration.'.freeze
+        EXIT_TYPES = [:break, :return].freeze
+        EACH_ = 'each_'.freeze
+        ENUMERATORS = [:collect, :collect_concat, :detect, :downto, :each,
+                       :find, :find_all, :find_index, :inject, :loop, :map!,
+                       :map, :reduce, :reject, :reject!, :reverse_each, :select,
+                       :select!, :times, :upto].freeze
 
         def on_block(node)
           block_owner, _, body = *node
-          return unless block_owner.type == :send
-          return if body.nil?
+          return unless block_owner.send_type?
+          return unless body && ends_with_condition?(body)
 
           _, method_name = *block_owner
           return unless enumerator?(method_name)
-          return unless ends_with_condition?(body)
 
-          add_offense(block_owner, :selector, MSG)
+          offense_node = offense_node(body)
+          add_offense(offense_node, offense_location(offense_node), MSG)
         end
 
         def on_while(node)
           _, body = *node
           return unless body && ends_with_condition?(body)
 
-          add_offense(node, :keyword, MSG)
+          offense_node = offense_node(body)
+          add_offense(offense_node, offense_location(offense_node), MSG)
         end
         alias_method :on_until, :on_while
 
         def on_for(node)
           _, _, body = *node
-          return unless ends_with_condition?(body)
+          return unless body && ends_with_condition?(body)
 
-          add_offense(node, :keyword, MSG)
+          offense_node = offense_node(body)
+          add_offense(offense_node, offense_location(offense_node), MSG)
         end
 
         private
 
         def enumerator?(method_name)
-          ENUMERATORS.include?(method_name) || /\Aeach_/.match(method_name)
+          ENUMERATORS.include?(method_name) ||
+            method_name.to_s.start_with?(EACH_)
         end
 
         def ends_with_condition?(body)
           return true if simple_if_without_break?(body)
 
-          body.type == :begin && simple_if_without_break?(body.children.last)
+          body.begin_type? && simple_if_without_break?(body.children.last)
         end
 
         def simple_if_without_break?(node)
+          return false unless node.if_type?
           return false if ternary_op?(node)
           return false if if_else?(node)
-          return false unless node.type == :if
           return false if style == :skip_modifier_ifs && modifier_if?(node)
           return false if !modifier_if?(node) && !min_body_length?(node)
 
@@ -79,7 +85,36 @@ module RuboCop
           _conditional, if_body, _else_body = *node
           return true unless if_body
 
-          ![:break, :return].include?(if_body.type)
+          !EXIT_TYPES.include?(if_body.type)
+        end
+
+        def offense_node(body)
+          *_, condition = *body
+          (condition && condition.if_type?) ? condition : body
+        end
+
+        def offense_location(offense_node)
+          condition_expression, = *offense_node
+          offense_begin_pos = offense_node.loc.expression.begin
+          offense_begin_pos.join(condition_expression.loc.expression)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            cond, if_body, else_body = *node
+            if if_body.nil?
+              opposite_kw = 'if'
+              body = else_body
+            else
+              opposite_kw = 'unless'
+              body = if_body
+            end
+            next_code = 'next ' << opposite_kw << ' ' <<
+                        cond.loc.expression.source << "\n"
+            corrector.insert_before(node.loc.expression, next_code)
+            corrector.replace(node.loc.expression,
+                              body.loc.expression.source)
+          end
         end
       end
     end

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

@@ -84,15 +84,19 @@ module RuboCop
         end
 
         def autocorrect_comparison(node)
+          expr = node.loc.expression.source
+
+          new_code =
+            if include_semantic_changes?
+              expr.sub(/\s*!=\s*nil/, '')
+            else
+              expr.sub(/^(\S*)\s*!=\s*nil/, '!\1.nil?')
+            end
+
+          return if expr == new_code
+
           lambda do |corrector|
-            expr = node.loc.expression
-            new_code =
-              if include_semantic_changes?
-                expr.source.sub(/\s*!=\s*nil/, '')
-              else
-                expr.source.sub(/^(\S*)\s*!=\s*nil/, '!\1.nil?')
-              end
-            corrector.replace(expr, new_code)
+            corrector.replace(node.loc.expression, new_code)
           end
         end
 

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

@@ -8,12 +8,16 @@ module RuboCop
       class OneLineConditional < Cop
         include OnNormalIfUnless
 
-        MSG = 'Favor the ternary operator (?:) ' \
-              'over if/then/else/end constructs.'
+        MSG = 'Favor the ternary operator (`?:`) ' \
+              'over `%s/then/else/end` constructs.'
 
         def on_normal_if_unless(node)
-          return if node.loc.expression.source.include?("\n")
-          add_offense(node, :expression, MSG)
+          exp = node.loc.expression.source
+          return if exp.include?("\n")
+          return unless node.loc.respond_to?(:else) && node.loc.else
+          condition = exp.include?('if') ? 'if' : 'unless'
+
+          add_offense(node, :expression, format(MSG, condition))
         end
       end
     end

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

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for options hashes and discourages them if the
+      # current Ruby version supports keyword arguments.
+      #
+      # @example
+      #   Instead of:
+      #
+      #   def fry(options = {})
+      #     temperature = options.fetch(:temperature, 300)
+      #     ...
+      #   end
+      #
+      #   Prefer:
+      #
+      #   def fry(temperature: 300)
+      #     ...
+      #   end
+      class OptionHash < Cop
+        MSG = 'Prefer keyword arguments to options hashes.'
+
+        def on_args(node)
+          return unless supports_keyword_arguments?
+
+          *_but_last, last_arg = *node
+
+          # asserting that there was an argument at all
+          return unless last_arg
+
+          # asserting last argument is an optional argument
+          return unless last_arg.optarg_type?
+
+          arg, default_value = *last_arg
+
+          # asserting default value is a hash
+          return unless default_value.hash_type?
+
+          # asserting default value is empty hash
+          *key_value_pairs = *default_value
+          return unless key_value_pairs.empty?
+
+          # Check for suspicious argument names
+          return unless name_in_suspicious_param_names?(arg)
+
+          add_offense(last_arg, :expression, MSG)
+        end
+
+        private
+
+        def supports_keyword_arguments?
+          RUBY_VERSION >= '2.0.0'
+        end
+
+        def name_in_suspicious_param_names?(arg_name)
+          cop_config.key?('SuspiciousParamNames') &&
+            cop_config['SuspiciousParamNames'].include?(arg_name.to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for optional arguments to methods
+      # that do not come at the end of the argument list
+      #
+      # @example
+      #   # bad
+      #   def foo(a = 1, b, c)
+      #   end
+      #
+      #   # good
+      #   def baz(a, b, c = 1)
+      #   end
+      #
+      #   def foobar(a = 1, b = 2, c = 3)
+      #   end
+      class OptionalArguments < Cop
+        MSG =
+          'Optional arguments should appear at the end of the argument list.'
+
+        def on_def(node)
+          _method, arguments, = *node
+          arguments = *arguments
+          optarg_positions = []
+          arg_positions = []
+
+          arguments.each_with_index do |argument, index|
+            optarg_positions << index if argument.optarg_type?
+            arg_positions << index if argument.arg_type?
+          end
+
+          return if optarg_positions.empty? || arg_positions.empty?
+
+          optarg_positions.each do |optarg_position|
+            # there can only be one group of optional arguments
+            break if optarg_position > arg_positions.max
+            argument = arguments[optarg_position]
+            arg, = *argument
+
+            add_offense(argument, :expression, format(MSG, arg))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,218 @@
+# encoding: utf-8
+
+require 'tsort'
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for simple usages of parallel assignment.
+      # This will only complain when the number of variables
+      # being assigned matched the number of assigning variables.
+      #
+      # @example
+      #   # bad
+      #   a, b, c = 1, 2, 3
+      #   a, b, c = [1, 2, 3]
+      #
+      #   # good
+      #   one, two = *foo
+      #   a, b = foo()
+      #   a, b = b, a
+      #
+      #   a = 1
+      #   b = 2
+      #   c = 3
+      class ParallelAssignment < Cop
+        include IfNode
+
+        MSG = 'Do not use parallel assignment.'
+
+        def on_masgn(node)
+          left, right = *node
+          left_elements = *left
+          right_elements = [*right].compact # edge case for one constant
+
+          # only complain when the number of variables matches
+          return if left_elements.size != right_elements.size
+
+          # account for edge cases using one variable with a comma
+          return if left_elements.size == 1
+
+          # account for edge case of Constant::CONSTANT
+          return unless right.array_type?
+
+          # allow mass assignment as the return of a method call
+          return if right.block_type? || right.send_type?
+
+          # allow mass assignment when using splat
+          return if (left_elements + right_elements).any?(&:splat_type?)
+
+          order = find_valid_order(left_elements, right_elements)
+          # For `a, b = b, a` or similar, there is no valid order
+          return if order.nil?
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            left, right = *node
+            left_elements = *left
+            right_elements = [*right].compact
+            order = find_valid_order(left_elements, right_elements)
+
+            assignment_corrector =
+              if modifier_statement?(node.parent)
+                ModifierCorrector.new(node, config, order)
+              elsif rescue_modifier?(node.parent)
+                RescueCorrector.new(node, config, order)
+              else
+                GenericCorrector.new(node, config, order)
+              end
+
+            corrector.replace(assignment_corrector.correction_range,
+                              assignment_corrector.correction)
+          end
+        end
+
+        private
+
+        def find_valid_order(left_elements, right_elements)
+          # arrange left_elements in an order such that no corresponding right
+          # element refers to a left element earlier in the sequence
+          # this can be done using an algorithm called a "topological sort"
+          # fortunately for us, Ruby's stdlib contains an implementation
+          assignments = left_elements.zip(right_elements)
+
+          begin
+            AssignmentSorter.new(assignments).tsort
+          rescue TSort::Cyclic
+            nil
+          end
+        end
+
+        # Helper class necessitated by silly design of TSort prior to Ruby 2.1
+        # Newer versions have a better API, but that doesn't help us
+        class AssignmentSorter
+          include TSort
+          extend RuboCop::NodePattern::Macros
+
+          def_node_matcher :var_name, '{(casgn _ $_) (_ $_)}'
+          def_node_search :uses_var?, '{({lvar ivar cvar gvar} %) (const _ %)}'
+
+          def initialize(assignments)
+            @assignments = assignments
+          end
+
+          def tsort_each_node
+            @assignments.each { |a| yield a }
+          end
+
+          def tsort_each_child(assignment)
+            # yield all the assignments which must come after `assignment`
+            # (due to dependencies on the previous value of the assigned var)
+            my_lhs, _my_rhs = *assignment
+
+            @assignments.each do |other|
+              _other_lhs, other_rhs = *other
+              yield other if uses_var?(other_rhs, var_name(my_lhs))
+            end
+          end
+        end
+
+        def modifier_statement?(node)
+          node &&
+            ((node.if_type? && modifier_if?(node)) ||
+            ((node.while_type? || node.until_type?) && modifier_while?(node)))
+        end
+
+        def modifier_while?(node)
+          node.loc.respond_to?(:keyword) &&
+            %w(while until).include?(node.loc.keyword.source) &&
+            node.loc.respond_to?(:end) && node.loc.end.nil?
+        end
+
+        def rescue_modifier?(node)
+          node &&
+            node.rescue_type? &&
+            (node.parent.nil? || !node.parent.kwbegin_type?)
+        end
+
+        # An internal class for correcting parallel assignment
+        class GenericCorrector
+          include AutocorrectAlignment
+
+          attr_reader :config, :node, :correction, :correction_range
+
+          def initialize(node, config, new_elements)
+            @node = node
+            @config = config
+            @new_elements = new_elements
+          end
+
+          def correction
+            "#{assignment.join("\n#{offset(node)}")}"
+          end
+
+          def correction_range
+            node.loc.expression
+          end
+
+          protected
+
+          def assignment
+            @new_elements.map do |lhs, rhs|
+              "#{lhs.loc.expression.source} = #{rhs.loc.expression.source}"
+            end
+          end
+
+          private
+
+          def extract_sources(node)
+            node.children.map { |child| child.loc.expression.source }
+          end
+        end
+
+        # An internal class for correcting parallel assignment
+        # protected by rescue
+        class RescueCorrector < GenericCorrector
+          def correction
+            _node, rescue_clause = *node.parent
+            _, _, rescue_result = *rescue_clause
+
+            "begin\n" <<
+              indentation(node) << assignment.join("\n#{indentation(node)}") <<
+              "\n#{offset(node)}rescue\n" <<
+              indentation(node) << rescue_result.loc.expression.source <<
+              "\n#{offset(node)}end"
+          end
+
+          def correction_range
+            node.parent.loc.expression
+          end
+        end
+
+        # An internal class for correcting parallel assignment
+        # guarded by if, unless, while, or until
+        class ModifierCorrector < GenericCorrector
+          def correction
+            parent = node.parent
+
+            modifier_range =
+              Parser::Source::Range.new(parent.loc.expression.source_buffer,
+                                        parent.loc.keyword.begin_pos,
+                                        parent.loc.expression.end_pos)
+
+            "#{modifier_range.source}\n" <<
+              indentation(node) << assignment.join("\n#{indentation(node)}") <<
+              "\n#{offset(node)}end"
+          end
+
+          def correction_range
+            node.parent.loc.expression
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -33,7 +33,7 @@ module RuboCop
           delimiters = preferred_delimiters(type)
 
           "`#{type}`-literals should be delimited by " \
-          "`#{delimiters[0]}` and `#{delimiters[1]}`"
+          "`#{delimiters[0]}` and `#{delimiters[1]}`."
         end
 
         private
@@ -43,20 +43,9 @@ module RuboCop
 
           opening_delimiter, closing_delimiter = preferred_delimiters(type)
 
-          first_child, *_middle, last_child = *node
-          opening_newline = new_line(node.loc.begin, first_child)
-          expression_indentation = leading_whitespace(first_child, :expression)
-          closing_newline = new_line(node.loc.end, last_child)
-          closing_indentation = leading_whitespace(node, :end)
-          expression, reg_opt = *contents(node)
-
-          corrected_source =
-            type + opening_delimiter + opening_newline +
-            expression_indentation + expression + closing_newline +
-            closing_indentation + closing_delimiter + reg_opt
-
           lambda do |corrector|
-            corrector.replace(node.loc.expression, corrected_source)
+            corrector.replace(node.loc.begin, "#{type}#{opening_delimiter}")
+            corrector.replace(node.loc.end, closing_delimiter)
           end
         end
 
@@ -72,49 +61,6 @@ module RuboCop
           cop_config['PreferredDelimiters'][type].split(//)
         end
 
-        def leading_whitespace(object, part)
-          case object
-          when String
-            ''
-          when NilClass
-            ''
-          when Parser::AST::Node
-            part_range = object.loc.send(part)
-            left_of_part = part_range.source_line[0...part_range.column]
-            /^(\s*)$/.match(left_of_part) ? left_of_part : ''
-          else
-            fail "Unsupported object #{object}"
-          end
-        end
-
-        def contents(node)
-          first_child, *middle, last_child = *node
-          last_child ||= first_child
-          if node.type == :regexp
-            *_, next_to_last_child = *middle
-            next_to_last_child ||= first_child
-            expression = source(node, first_child, next_to_last_child)
-            reg_opt = last_child.loc.expression.source
-          else
-            expression = if first_child.is_a?(Parser::AST::Node)
-                           source(node, first_child, last_child)
-                         else
-                           first_child.to_s
-                         end
-            reg_opt = ''
-          end
-
-          [expression, reg_opt]
-        end
-
-        def source(node, begin_node, end_node)
-          Parser::Source::Range.new(
-            node.loc.expression.source_buffer,
-            begin_node.loc.expression.begin_pos,
-            end_node.loc.expression.end_pos
-          ).source
-        end
-
         def uses_preferred_delimiter?(node, type)
           preferred_delimiters(type)[0] == begin_source(node)[-1]
         end
@@ -133,15 +79,6 @@ module RuboCop
             node.loc.expression.source
           end
         end
-
-        def new_line(range, child_node)
-          same_line?(range, child_node) ? '' : "\n"
-        end
-
-        def same_line?(range, child_node)
-          !child_node.is_a?(Parser::AST::Node) ||
-            range.begin.line == child_node.loc.line
-        end
       end
     end
   end

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

@@ -23,10 +23,11 @@ module RuboCop
         private
 
         def on_method_def(node, method_name, _args, _body)
-          predicate_prefices.each do |prefix|
+          predicate_prefixes.each do |prefix|
             method_name = method_name.to_s
             next unless method_name.start_with?(prefix)
             next if method_name == expected_name(method_name, prefix)
+            next if predicate_whitelist.include?(method_name)
             add_offense(
               node,
               :name,
@@ -53,9 +54,13 @@ module RuboCop
           cop_config['NamePrefixBlacklist']
         end
 
-        def predicate_prefices
+        def predicate_prefixes
           cop_config['NamePrefix']
         end
+
+        def predicate_whitelist
+          cop_config['NameWhitelist']
+        end
       end
     end
   end

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

@@ -37,19 +37,8 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            child = node.children.first
-
-            begin_indent = node.loc.column
-            child_indent = child.loc.column
-
-            indent_diff = child_indent - begin_indent
-
-            corrector.replace(
-              range_with_surrounding_space(node.loc.expression),
-              range_with_surrounding_space(
-                child.loc.expression
-              ).source.gsub(/^[ \t]{#{indent_diff}}/, '')
-            )
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
           end
         end
       end

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