rubbycop 0.49.0

data/lib/rubbycop/cop/lint/duplicated_key.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for duplicated keys in hash literals.
+      #
+      # This cop mirrors a warning in Ruby 2.2.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   hash = { food: 'apple', food: 'orange' }
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   hash = { food: 'apple', other_food: 'orange' }
+      class DuplicatedKey < Cop
+        include Duplication
+
+        MSG = 'Duplicated key in hash literal.'.freeze
+
+        def on_hash(node)
+          keys = node.keys.select(&:recursive_basic_literal?)
+
+          return unless duplicates?(keys)
+
+          consecutive_duplicates(keys).each do |key|
+            add_offense(key, :expression)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/each_with_object_argument.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks if each_with_object is called with an immutable
+      # argument. Since the argument is the object that the given block shall
+      # make calls on to build something based on the enumerable that
+      # each_with_object iterates over, an immutable argument makes no sense.
+      # It's definitely a bug.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   sum = numbers.each_with_object(0) { |e, a| a += e }
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   num = 0
+      #   sum = numbers.each_with_object(num) { |e, a| a += e }
+      class EachWithObjectArgument < Cop
+        MSG = 'The argument to each_with_object can not be immutable.'.freeze
+
+        def_node_matcher :each_with_object?, '(send _ :each_with_object $_)'
+
+        def on_send(node)
+          each_with_object?(node) do |arg|
+            return unless arg.immutable_literal?
+
+            add_offense(node, :expression)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/else_layout.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for odd else block layout - like
+      # having an expression on the same line as the else keyword,
+      # which is usually a mistake.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   if something
+      #     ...
+      #   else do_this
+      #     do_that
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   if something
+      #     ...
+      #   else
+      #     do_this
+      #     do_that
+      #   end
+      class ElseLayout < Cop
+        MSG = 'Odd `else` layout detected. Did you mean to use `elsif`?'.freeze
+
+        def on_if(node)
+          return if node.ternary? || node.elsif?
+
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return unless node.else_branch
+
+          if node.else? && node.loc.else.is?('else')
+            check_else(node)
+          elsif node.if?
+            check(node.else_branch)
+          end
+        end
+
+        def check_else(node)
+          else_branch = node.else_branch
+
+          return unless else_branch.begin_type?
+
+          first_else = else_branch.children.first
+
+          return unless first_else.source_range.line == node.loc.else.line
+
+          add_offense(first_else, :expression)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/empty_ensure.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for empty `ensure` blocks
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     do_something
+      #   ensure
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #   end
+      class EmptyEnsure < Cop
+        MSG = 'Empty `ensure` block detected.'.freeze
+
+        def on_ensure(node)
+          add_offense(node, :keyword) unless node.body
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.keyword)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/empty_expression.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for the presence of empty expressions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   foo = ()
+      #   if ()
+      #     bar
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   foo = (some_expression)
+      #   if (some_expression)
+      #     bar
+      #   end
+      class EmptyExpression < Cop
+        MSG = 'Avoid empty expressions.'.freeze
+
+        def on_begin(node)
+          return unless empty_expression?(node)
+
+          add_offense(node, node.source_range, MSG)
+        end
+
+        private
+
+        def empty_expression?(begin_node)
+          begin_node.children.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/empty_interpolation.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for empty interpolation.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   "result is #{}"
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   "result is #{some_result}"
+      class EmptyInterpolation < Cop
+        MSG = 'Empty interpolation detected.'.freeze
+
+        def on_dstr(node)
+          node.each_child_node(:begin) do |begin_node|
+            add_offense(begin_node, :expression) if begin_node.children.empty?
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |collector|
+            collector.remove(node.loc.expression)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/empty_when.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for the presence of `when` branches without a body.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   case foo
+      #   when bar then 1
+      #   when baz then # nothing
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   case foo
+      #   when bar then 1
+      #   when baz then 2
+      #   end
+      class EmptyWhen < Cop
+        MSG = 'Avoid `when` branches without a body.'.freeze
+
+        def on_case(node)
+          node.each_when do |when_node|
+            next if when_node.body
+
+            add_offense(when_node, when_node.source_range, MSG)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/end_alignment.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks whether the end keywords are aligned properly.
+      #
+      # Three modes are supported through the `EnforcedStyleAlignWith`
+      # configuration parameter:
+      #
+      # If it's set to `keyword` (which is the default), the `end`
+      # shall be aligned with the start of the keyword (if, class, etc.).
+      #
+      # If it's set to `variable` the `end` shall be aligned with the
+      # left-hand-side of the variable assignment, if there is one.
+      #
+      # If it's set to `start_of_line`, the `end` shall be aligned with the
+      # start of the line where the matching keyword appears.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: keyword (default)
+      #
+      #   # good
+      #
+      #   variable = if true
+      #              end
+      #
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: variable
+      #
+      #   # good
+      #
+      #   variable = if true
+      #   end
+      #
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: start_of_line
+      #
+      #   # good
+      #
+      #   puts(if true
+      #   end)
+      class EndAlignment < Cop
+        include CheckAssignment
+        include EndKeywordAlignment
+
+        def on_class(node)
+          check_other_alignment(node)
+        end
+
+        def on_module(node)
+          check_other_alignment(node)
+        end
+
+        def on_if(node)
+          check_other_alignment(node) unless node.ternary?
+        end
+
+        def on_while(node)
+          check_other_alignment(node)
+        end
+
+        def on_until(node)
+          check_other_alignment(node)
+        end
+
+        def on_case(node)
+          if node.argument?
+            check_asgn_alignment(node.parent, node)
+          else
+            check_other_alignment(node)
+          end
+        end
+
+        private
+
+        def check_assignment(node, rhs)
+          # If there are method calls chained to the right hand side of the
+          # assignment, we let rhs be the receiver of those method calls before
+          # we check if it's an if/unless/while/until.
+          return unless (rhs = first_part_of_call_chain(rhs))
+          return unless CONDITIONAL_NODES.include?(rhs.type)
+          return if rhs.if_type? && rhs.ternary?
+
+          check_asgn_alignment(node, rhs)
+        end
+
+        def check_asgn_alignment(outer_node, inner_node)
+          align_with = {
+            keyword: inner_node.loc.keyword,
+            start_of_line: start_line_range(outer_node),
+            variable: asgn_variable_align_with(outer_node, inner_node)
+          }
+
+          check_end_kw_alignment(inner_node, align_with)
+          ignore_node(inner_node)
+        end
+
+        def asgn_variable_align_with(outer_node, inner_node)
+          expr = outer_node.source_range
+
+          if !line_break_before_keyword?(expr, inner_node)
+            range_between(expr.begin_pos, inner_node.loc.keyword.end_pos)
+          else
+            inner_node.loc.keyword
+          end
+        end
+
+        def check_other_alignment(node)
+          align_with = {
+            keyword: node.loc.keyword,
+            variable: node.loc.keyword,
+            start_of_line: start_line_range(node)
+          }
+          check_end_kw_alignment(node, align_with)
+        end
+
+        def autocorrect(node)
+          align(node, alignment_node(node))
+        end
+
+        def alignment_node(node)
+          if style == :keyword
+            node
+          elsif style == :variable
+            return node.parent if node.case_type? && node.argument?
+            # Fall back to 'keyword' style if this node is not on the RHS
+            # of an assignment
+            node.ancestors.find(&:assignment?) || node
+          else
+            start_line_range(node)
+          end
+        end
+
+        def start_line_range(node)
+          expr   = node.source_range
+          buffer = expr.source_buffer
+          source = buffer.source_line(expr.line)
+          range  = buffer.line_range(expr.line)
+
+          range_between(range.begin_pos + (source =~ /\S/),
+                        range.begin_pos + (source =~ /\s*\z/))
+        end
+      end
+    end
+  end
+end