rubocop 0.32.1 → 0.33.0

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

@@ -0,0 +1,56 @@
+# 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?
+
+          _, 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?
+
+          add_offense(last_arg, :expression, MSG)
+        end
+
+        private
+
+        def supports_keyword_arguments?
+          RUBY_VERSION >= '2.0.0'
+        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

@@ -37,6 +37,9 @@ module RuboCop
           # 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?
 

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/redundant_return.rb

@@ -34,16 +34,33 @@ module RuboCop
               next
             end
 
+            return_value, = *node
             if node.children.size > 1
-              kids = node.children.map { |child| child.loc.expression }
-              corrector.insert_before(kids.first, '[')
-              corrector.insert_after(kids.last, ']')
+              add_brackets(corrector, node)
+            elsif return_value.hash_type?
+              add_braces(corrector, return_value) unless braces?(return_value)
             end
             return_kw = range_with_surrounding_space(node.loc.keyword, :right)
             corrector.remove(return_kw)
           end
         end
 
+        def braces?(arg)
+          arg.loc.begin
+        end
+
+        def add_brackets(corrector, node)
+          kids = node.children.map { |child| child.loc.expression }
+          corrector.insert_before(kids.first, '[')
+          corrector.insert_after(kids.last, ']')
+        end
+
+        def add_braces(corrector, node)
+          kids = node.children.map { |child| child.loc.expression }
+          corrector.insert_before(kids.first, '{')
+          corrector.insert_after(kids.last, '}')
+        end
+
         def arguments?(args)
           return false if args.empty?
           return true if args.size > 1

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

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether the rescue and ensure keywords are aligned
+      # properly.
+      #
+      # @example
+      #
+      #   # bad
+      #   begin
+      #     something
+      #     rescue
+      #     puts 'error'
+      #   end
+      #
+      #   # good
+      #   begin
+      #     something
+      #   rescue
+      #     puts 'error'
+      #   end
+      class RescueEnsureAlignment < Cop
+        MSG = '`%s` at %d, %d is not aligned with `end` at %d, %d.'
+
+        def on_resbody(node)
+          check(node) unless modifier?(node)
+        end
+
+        def on_ensure(node)
+          check(node)
+        end
+
+        def investigate(processed_source)
+          @modifier_locations = processed_source.tokens
+                                .select { |t| t.type == :kRESCUE_MOD }
+                                .map(&:pos)
+        end
+
+        def autocorrect(node)
+          source_buffer = node.loc.keyword.source_buffer
+          begin_pos = node.loc.keyword.begin_pos
+          current_column = node.loc.keyword.column
+          whitespace = Parser::Source::Range.new(source_buffer,
+                                                 begin_pos - current_column,
+                                                 begin_pos)
+          return false unless whitespace.source.strip.empty?
+
+          new_column = ancestor_node(node).loc.end.column
+          ->(corrector) { corrector.replace(whitespace, ' ' * new_column) }
+        end
+
+        private
+
+        def check(node)
+          end_loc = ancestor_node(node).loc.end
+          return if end_loc.column == node.loc.keyword.column
+
+          kw_loc = node.loc.keyword
+
+          add_offense(node, kw_loc,
+                      format(MSG, kw_loc.source, kw_loc.line, kw_loc.column,
+                             end_loc.line, end_loc.column))
+        end
+
+        def modifier?(node)
+          @modifier_locations.include? node.loc.keyword
+        end
+
+        def ancestor_node(node)
+          node.each_ancestor(:kwbegin, :def, :defs).first
+        end
+      end
+    end
+  end
+end

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

@@ -5,36 +5,12 @@ module RuboCop
     module Style
       # This cop checks for uses of rescue in its modifier form.
       class RescueModifier < Cop
-        include OnMethodDef
-
         MSG = 'Avoid using `rescue` in its modifier form.'
 
-        def on_rescue(node)
-          return if ignored_node?(node)
-
-          add_offense(node, :expression)
-        end
-
-        def on_kwbegin(node)
-          body, *_ = *node
-          check(body)
-        end
-
-        def on_method_def(_node, _method_name, _args, body)
-          check(body)
-        end
-
-        def check(body)
-          return unless body
-
-          case body.type
-          when :rescue
-            ignore_node(body)
-          when :ensure
-            first_child = body.children.first
-            if first_child && first_child.type == :rescue
-              ignore_node(first_child)
-            end
+        def investigate(processed_source)
+          processed_source.tokens.each do |t|
+            next unless t.type == :kRESCUE_MOD
+            add_offense(nil, t.pos)
           end
         end
       end

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the use of the send method.
+      class Send < Cop
+        MSG = 'Prefer `Object#__send__` or `Object#public_send` to `send`.'
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+          return unless method_name == :send && args.length > 0
+          add_offense(node, :selector)
+        end
+      end
+    end
+  end
+end

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

@@ -5,22 +5,32 @@ module RuboCop
     module Style
       # This cop checks for whitespace within string interpolations.
       #
-      # Good:
-      #    var = "This is the #{good} example"
-      #
-      # Bad:
-      #    var = "This is the #{ bad } example"
+      # @example
+      #   # Good if EnforcedStyle is no_space, bad if space.
+      #      var = "This is the #{no_space} example"
       #
+      #   # Good if EnforceStyle is space, bad if no_space.
+      #      var = "This is the #{ space } example"
       class SpaceInsideStringInterpolation < Cop
-        MSG = 'Space inside string interpolation detected.'
+        include ConfigurableEnforcedStyle
+
+        NO_SPACE_MSG = 'Space inside string interpolation detected.'
+        SPACE_MSG = 'Missing space around string interpolation detected.'
 
         def on_dstr(node)
           node.children.select { |n| n.type == :begin }.each do |begin_node|
             final_node = begin_node.children.last
 
             interp = final_node.loc.expression
-            if range_with_surrounding_space(interp) != interp
-              add_offense(final_node, :expression)
+            interp_with_surrounding_space = range_with_surrounding_space(interp)
+            if style == :no_space
+              if interp_with_surrounding_space != interp
+                add_offense(final_node, :expression, NO_SPACE_MSG)
+              end
+            elsif style == :space
+              if interp_with_surrounding_space.source != " #{interp.source} "
+                add_offense(final_node, :expression, SPACE_MSG)
+              end
             end
           end
         end
@@ -28,11 +38,20 @@ module RuboCop
         private
 
         def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(
-              range_with_surrounding_space(node.loc.expression),
-              node.loc.expression.source
-            )
+          if style == :no_space
+            lambda do |corrector|
+              corrector.replace(
+                range_with_surrounding_space(node.loc.expression),
+                node.loc.expression.source
+              )
+            end
+          elsif style == :space
+            lambda do |corrector|
+              corrector.replace(
+                range_with_surrounding_space(node.loc.expression),
+                " #{node.loc.expression.source} "
+              )
+            end
           end
         end
       end