rubocop 0.35.1 → 0.36.0

data/lib/rubocop/cop/lint/space_before_first_arg.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # Checks for space between a method name and the first argument for
-      # method calls without parentheses.
-      #
-      # @example
-      #
-      #   something?x
-      #   something!x
-      #
-      class SpaceBeforeFirstArg < Cop
-        MSG = 'Put space between the method name and the first argument.'
-
-        def on_send(node)
-          return if parentheses?(node)
-
-          _receiver, method_name, *args = *node
-          return if args.empty?
-          return if operator?(method_name)
-          return if node.asgn_method_call?
-
-          # Setter calls with parentheses are parsed this way. The parentheses
-          # belong to the argument, not the send node.
-          return if args.first.type == :begin
-
-          arg1 = args.first.loc.expression
-          arg1_with_space = range_with_surrounding_space(arg1, :left)
-          space = Parser::Source::Range.new(arg1.source_buffer,
-                                            arg1_with_space.begin_pos,
-                                            arg1.begin_pos)
-
-          add_offense(space, arg1) if arg1_with_space.source =~ /\A\S/
-        end
-
-        def autocorrect(range)
-          ->(corrector) { corrector.insert_before(range, ' ') }
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/rails/default_scope.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for default_scope calls when it was passed
-      # a lambda or a proc instead of a block.
-      #
-      # @example
-      #
-      #   # incorrect
-      #   default_scope -> { something }
-      #
-      #   # correct
-      #   default_scope { something }
-      class DefaultScope < Cop
-        MSG = '`default_scope` expects a block as its sole argument.'
-
-        def on_send(node)
-          return unless command?(:default_scope, node)
-
-          _receiver, _method_name, *args = *node
-          return unless args.size == 1
-
-          first_arg = args[0]
-          return unless first_arg.type != :block || lambda_or_proc?(first_arg)
-
-          add_offense(first_arg, :expression)
-        end
-      end
-    end
-  end
-end

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

@@ -1,182 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for trailing comma in parameter lists and literals.
-      #
-      # @example
-      #   # always bad
-      #   a = [1, 2,]
-      #
-      #   # good if EnforcedStyleForMultiline is consistent_comma
-      #   a = [
-      #     1, 2,
-      #     3,
-      #   ]
-      #
-      #   # good if EnforcedStyleForMultiline is comma or consistent_comma
-      #   a = [
-      #     1,
-      #     2,
-      #   ]
-      #
-      #   # good if EnforcedStyleForMultiline is no_comma
-      #   a = [
-      #     1,
-      #     2
-      #   ]
-      class TrailingComma < Cop
-        include ArraySyntax
-        include ConfigurableEnforcedStyle
-
-        MSG = '%s comma after the last %s'
-
-        def on_array(node)
-          check_literal(node, 'item of %s array') if square_brackets?(node)
-        end
-
-        def on_hash(node)
-          check_literal(node, 'item of %s hash')
-        end
-
-        def on_send(node)
-          _receiver, _method_name, *args = *node
-          return if args.empty?
-          # It's impossible for a method call without parentheses to have
-          # a trailing comma.
-          return unless brackets?(node)
-
-          check(node, args, 'parameter of %s method call',
-                args.last.loc.expression.end_pos, node.loc.expression.end_pos)
-        end
-
-        private
-
-        def parameter_name
-          'EnforcedStyleForMultiline'
-        end
-
-        def check_literal(node, kind)
-          return if node.children.empty?
-          # A braceless hash is the last parameter of a method call and will be
-          # checked as such.
-          return unless brackets?(node)
-
-          check(node, node.children, kind,
-                node.children.last.loc.expression.end_pos,
-                node.loc.end.begin_pos)
-        end
-
-        def check(node, items, kind, begin_pos, end_pos)
-          sb = items.first.loc.expression.source_buffer
-
-          after_last_item = Parser::Source::Range.new(sb, begin_pos, end_pos)
-
-          return if heredoc?(after_last_item.source)
-
-          comma_offset = after_last_item.source =~ /,/
-
-          if comma_offset && !inside_comment?(after_last_item, comma_offset)
-            unless should_have_comma?(style, node, items)
-              extra_info = case style
-                           when :comma
-                             ', unless each item is on its own line'
-                           when :consistent_comma
-                             ', unless items are split onto multiple lines'
-                           else
-                             ''
-                           end
-              avoid_comma(kind, after_last_item.begin_pos + comma_offset, sb,
-                          extra_info)
-            end
-          elsif should_have_comma?(style, node, items)
-            put_comma(items, kind, sb)
-          end
-        end
-
-        def should_have_comma?(style, node, items)
-          [:comma, :consistent_comma].include?(style) &&
-            multiline?(node) &&
-            (items.size > 1 || items.last.hash_type?)
-        end
-
-        def inside_comment?(range, comma_offset)
-          processed_source.comments.any? do |comment|
-            comment_offset = comment.loc.expression.begin_pos - range.begin_pos
-            comment_offset >= 0 && comment_offset < comma_offset
-          end
-        end
-
-        def heredoc?(source_after_last_item)
-          source_after_last_item =~ /\w/
-        end
-
-        # Returns true if the node has round/square/curly brackets.
-        def brackets?(node)
-          node.loc.end
-        end
-
-        # Returns true if the round/square/curly brackets of the given node are
-        # on different lines, and each item within is on its own line, and the
-        # closing bracket is on its own line.
-        def multiline?(node)
-          elements = if node.type == :send
-                       _receiver, _method_name, *args = *node
-                       args.flat_map { |a| a.type == :hash ? a.children : a }
-                     else
-                       node.children
-                     end
-
-          # Without this check, Foo.new({}) is considered multiline, which
-          # it should not be. Essentially, if there are no elements, the
-          # expression can not be multiline.
-          return if elements.empty?
-
-          items = elements.map { |e| e.loc.expression }
-          if style == :consistent_comma
-            items.each_cons(2).any? { |a, b| !on_same_line?(a, b) }
-          else
-            items << node.loc.end
-            items.each_cons(2).all? { |a, b| !on_same_line?(a, b) }
-          end
-        end
-
-        def on_same_line?(a, b)
-          a.line + a.source.count("\n") == b.line
-        end
-
-        def avoid_comma(kind, comma_begin_pos, sb, extra_info)
-          range = Parser::Source::Range.new(sb, comma_begin_pos,
-                                            comma_begin_pos + 1)
-          article = kind =~ /array/ ? 'an' : 'a'
-          add_offense(range, range,
-                      format(MSG, 'Avoid', format(kind, article)) +
-                      "#{extra_info}.")
-        end
-
-        def put_comma(items, kind, sb)
-          last_item = items.last
-          return if last_item.type == :block_pass
-
-          last_expr = last_item.loc.expression
-          ix = last_expr.source.rindex("\n") || 0
-          ix += last_expr.source[ix..-1] =~ /\S/
-          range = Parser::Source::Range.new(sb, last_expr.begin_pos + ix,
-                                            last_expr.end_pos)
-          add_offense(range, range,
-                      format(MSG, 'Put a', format(kind, 'a multiline') + '.'))
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            case range.source
-            when ',' then corrector.remove(range)
-            else          corrector.insert_after(range, ',')
-            end
-          end
-        end
-      end
-    end
-  end
-end