rubocop 0.75.1

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

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for empty else-clauses, possibly including comments and/or an
+      # explicit `nil` depending on the EnforcedStyle.
+      #
+      # @example EnforcedStyle: empty
+      #   # warn only on empty else
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     nil
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
+      #
+      # @example EnforcedStyle: nil
+      #   # warn on else with nil in it
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #     nil
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
+      #
+      # @example EnforcedStyle: both (default)
+      #   # warn on empty else and else with nil in it
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
+      class EmptyElse < Cop
+        include OnNormalIfUnless
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG = 'Redundant `else`-clause.'
+
+        def on_normal_if_unless(node)
+          check(node)
+        end
+
+        def on_case(node)
+          check(node)
+        end
+
+        def autocorrect(node)
+          return false if autocorrect_forbidden?(node.type.to_s)
+          return false if comment_in_else?(node)
+
+          lambda do |corrector|
+            end_pos = base_node(node).loc.end.begin_pos
+            corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
+          end
+        end
+
+        private
+
+        def check(node)
+          empty_check(node) if empty_style?
+          nil_check(node) if nil_style?
+        end
+
+        def nil_style?
+          style == :nil || style == :both
+        end
+
+        def empty_style?
+          style == :empty || style == :both
+        end
+
+        def empty_check(node)
+          return unless node.else? && !node.else_branch
+
+          add_offense(node, location: :else)
+        end
+
+        def nil_check(node)
+          return unless node.else_branch&.nil_type?
+
+          add_offense(node, location: :else)
+        end
+
+        def comment_in_else?(node)
+          range = else_line_range(node.loc)
+          processed_source.find_comment { |c| range.include?(c.loc.line) }
+        end
+
+        def else_line_range(loc)
+          return 0..0 if loc.else.nil? || loc.end.nil?
+
+          loc.else.first_line..loc.end.first_line
+        end
+
+        def base_node(node)
+          return node if node.case_type?
+          return node unless node.elsif?
+
+          node.each_ancestor(:if, :case, :when).find(-> { node }) do |parent|
+            parent.loc.end
+          end
+        end
+
+        def autocorrect_forbidden?(type)
+          [type, 'both'].include?(missing_else_style)
+        end
+
+        def missing_else_style
+          missing_cfg = config.for_cop('Style/MissingElse')
+          missing_cfg.fetch('Enabled') ? missing_cfg['EnforcedStyle'] : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for parentheses for empty lambda parameters. Parentheses
+      # for empty lambda parameters do not cause syntax errors, but they are
+      # redundant.
+      #
+      # @example
+      #   # bad
+      #   -> () { do_something }
+      #
+      #   # good
+      #   -> { do_something }
+      #
+      #   # good
+      #   -> (arg) { do_something(arg) }
+      class EmptyLambdaParameter < Cop
+        include EmptyParameter
+        include RangeHelp
+
+        MSG = 'Omit parentheses for the empty lambda parameters.'
+
+        def on_block(node)
+          send_node = node.send_node
+          return unless send_node.send_type?
+
+          check(node) if node.send_node.lambda_literal?
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            send_node = node.parent.send_node
+            range = range_between(
+              send_node.loc.expression.end_pos,
+              node.loc.expression.end_pos
+            )
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the use of a method, the result of which
+      # would be a literal, like an empty array, hash, or string.
+      #
+      # @example
+      #   # bad
+      #   a = Array.new
+      #   h = Hash.new
+      #   s = String.new
+      #
+      #   # good
+      #   a = []
+      #   h = {}
+      #   s = ''
+      class EmptyLiteral < Cop
+        include FrozenStringLiteral
+        include RangeHelp
+
+        ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'
+        HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'
+        STR_MSG = 'Use string literal `%<prefer>s` instead of ' \
+                  '`String.new`.'
+
+        def_node_matcher :array_node, '(send (const nil? :Array) :new)'
+        def_node_matcher :hash_node, '(send (const nil? :Hash) :new)'
+        def_node_matcher :str_node, '(send (const nil? :String) :new)'
+        def_node_matcher :array_with_block,
+                         '(block (send (const nil? :Array) :new) args _)'
+        def_node_matcher :hash_with_block,
+                         '(block (send (const nil? :Hash) :new) args _)'
+
+        def on_send(node)
+          add_offense(node, message: ARR_MSG)  if offense_array_node?(node)
+          add_offense(node, message: HASH_MSG) if offense_hash_node?(node)
+
+          str_node(node) do
+            return if frozen_string_literals_enabled?
+
+            add_offense(node,
+                        message: format(STR_MSG,
+                                        prefer: preferred_string_literal))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(replacement_range(node), correction(node))
+          end
+        end
+
+        private
+
+        def preferred_string_literal
+          enforce_double_quotes? ? '""' : "''"
+        end
+
+        def enforce_double_quotes?
+          string_literals_config['EnforcedStyle'] == 'double_quotes'
+        end
+
+        def string_literals_config
+          config.for_cop('Style/StringLiterals')
+        end
+
+        def first_argument_unparenthesized?(node)
+          parent = node.parent
+          unless parent && %i[send super zsuper].include?(parent.type)
+            return false
+          end
+
+          node.object_id == parent.arguments.first.object_id &&
+            !parentheses?(node.parent)
+        end
+
+        def replacement_range(node)
+          if hash_node(node) &&
+             first_argument_unparenthesized?(node)
+            # `some_method {}` is not same as `some_method Hash.new`
+            # because the braces are interpreted as a block. We will have
+            # to rewrite the arguments to wrap them in parenthesis.
+            args = node.parent.arguments
+
+            range_between(args[0].loc.expression.begin_pos - 1,
+                          args[-1].loc.expression.end_pos)
+          else
+            node.source_range
+          end
+        end
+
+        def offense_array_node?(node)
+          array_node(node) && !array_with_block(node.parent)
+        end
+
+        def offense_hash_node?(node)
+          # If Hash.new takes a block, it can't be changed to {}.
+          hash_node(node) && !hash_with_block(node.parent)
+        end
+
+        def correction(node)
+          if offense_array_node?(node)
+            '[]'
+          elsif str_node(node)
+            preferred_string_literal
+          elsif offense_hash_node?(node)
+            if first_argument_unparenthesized?(node)
+              # `some_method {}` is not same as `some_method Hash.new`
+              # because the braces are interpreted as a block. We will have
+              # to rewrite the arguments to wrap them in parenthesis.
+              args = node.parent.arguments
+              "(#{args[1..-1].map(&:source).unshift('{}').join(', ')})"
+            else
+              '{}'
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the formatting of empty method definitions.
+      # By default it enforces empty method definitions to go on a single
+      # line (compact style), but it can be configured to enforce the `end`
+      # to go on its own line (expanded style).
+      #
+      # Note: A method definition is not considered empty if it contains
+      #       comments.
+      #
+      # @example EnforcedStyle: compact (default)
+      #   # bad
+      #   def foo(bar)
+      #   end
+      #
+      #   def self.foo(bar)
+      #   end
+      #
+      #   # good
+      #   def foo(bar); end
+      #
+      #   def foo(bar)
+      #     # baz
+      #   end
+      #
+      #   def self.foo(bar); end
+      #
+      # @example EnforcedStyle: expanded
+      #   # bad
+      #   def foo(bar); end
+      #
+      #   def self.foo(bar); end
+      #
+      #   # good
+      #   def foo(bar)
+      #   end
+      #
+      #   def self.foo(bar)
+      #   end
+      class EmptyMethod < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_COMPACT = 'Put empty method definitions on a single line.'
+        MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
+                       'next line.'
+
+        def on_def(node)
+          return if node.body || comment_lines?(node)
+          return if correct_style?(node)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, corrected(node))
+          end
+        end
+
+        private
+
+        def message(_node)
+          compact_style? ? MSG_COMPACT : MSG_EXPANDED
+        end
+
+        def correct_style?(node)
+          compact_style? && compact?(node) ||
+            expanded_style? && expanded?(node)
+        end
+
+        def corrected(node)
+          has_parentheses = parentheses?(node.arguments)
+
+          arguments   = node.arguments? ? node.arguments.source : ''
+          extra_space = node.arguments? && !has_parentheses ? ' ' : ''
+          scope       = node.receiver ? "#{node.receiver.source}." : ''
+
+          signature = [scope, node.method_name, extra_space, arguments].join
+
+          ["def #{signature}", 'end'].join(joint(node))
+        end
+
+        def joint(node)
+          indent = ' ' * node.loc.column
+
+          compact_style? ? '; ' : "\n#{indent}"
+        end
+
+        def comment_lines?(node)
+          processed_source[line_range(node)].any? { |line| comment_line?(line) }
+        end
+
+        def compact?(node)
+          node.single_line?
+        end
+
+        def expanded?(node)
+          node.multiline?
+        end
+
+        def compact_style?
+          style == :compact
+        end
+
+        def expanded_style?
+          style == :expanded
+        end
+      end
+    end
+  end
+end