rspec/rules/S1871/ruby/rule.adoc

Having two ``++when++`` clauses in a ``++case++`` statement or two branches in an ``++if++`` chain with the same implementation is at best duplicate code, and at worst a coding error. If the same logic is truly needed for both instances, then in an ``++if++`` chain they should be combined, or for a ``++case++``, duplicates should be refactored. 

== Noncompliant Code Example

----
case i
  when 1
    doFirstThing()
    doSomething()
  when 2
    doSomethingDifferent()
  when 3 # Noncompliant; duplicates case 1's implementation
    doFirstThing()
    doSomething()
  else
    doTheRest()
end

if a >= 0 && a < 10
  doFirstThing()
  doTheThing()
elsif a >= 10 && a < 20
  doTheOtherThing()
elsif a >= 20 && a < 50
  doFirstThing()
  doTheThing()   # Noncompliant; duplicates first condition
else
  doTheRest()
end
----

== Exceptions

Blocks in an ``++if++`` chain that contain a single line of code are ignored, as are blocks in a ``++case++`` statement that contain a single line of code.

----
if a == 
  doSomething()  # no issue, usually this is done on purpose to increase the readability
elsif a == 2
  doSomethingElse()
else
  doSomething()
end
----

But this exception does not apply to ``++if++`` chains without ``++else++``-s, or to ``++case++``-es without ``++else++`` clauses when all branches have the same single line of code. In case of ``++if++`` chains with ``++else++``-s, or of ``++case++``-es with ``++else++`` clauses, rule S3923 raises a bug. 

----
if a == 1
  doSomething()  # Noncompliant, this might have been done on purpose but probably not
elsif a == 2
  doSomething()
end
----