zombie-killer 0.2

data/spec/zombie_killer_spec.rb

@@ -0,0 +1,1148 @@
+# Generated from spec/zombie_killer_spec.md -- do not change!
+
+require "spec_helper"
+
+describe "ZombieKiller:" do
+  describe "table of contents:" do
+  end
+
+  describe "concepts:" do
+  end
+
+  describe "literals:" do
+    it "translates `Ops.add` of two string literals" do
+      original_code = cleanup(<<-EOT)
+        Ops.add("Hello", "World")
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        "Hello" + "World"
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "translates `Ops.add` of two integer literals" do
+      original_code = cleanup(<<-EOT)
+        Ops.add(40, 2)
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        40 + 2
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "translates assignment of `Ops.add` of two string literals" do
+      original_code = cleanup(<<-EOT)
+        v = Ops.add("Hello", "World")
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        v = "Hello" + "World"
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "does not translate Ops.add if any argument is ugly" do
+      original_code = cleanup(<<-EOT)
+        Ops.add("Hello", world)
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        Ops.add("Hello", world)
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "does not translate Ops.add if any argument is the nil literal" do
+      original_code = cleanup(<<-EOT)
+        Ops.add("Hello", nil)
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        Ops.add("Hello", nil)
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+  end
+
+  describe "variables:" do
+    it "translates `Ops.add(nice_variable, literal)`" do
+      original_code = cleanup(<<-EOT)
+        v = "Hello"
+        Ops.add(v, "World")
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        v = "Hello"
+        v + "World"
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "doesn't translate `Ops.add(nice_variable, literal)` when the variable got it's niceness via multiple assignemnt" do
+      original_code = cleanup(<<-EOT)
+        v1, v2 = "Hello", "World"
+        Ops.add(v1, v2)
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        v1, v2 = "Hello", "World"
+        Ops.add(v1, v2)
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "translates `Ops.add(nontrivially_nice_variable, literal)`" do
+      original_code = cleanup(<<-EOT)
+        v  = "Hello"
+        v2 = v
+        v  = uglify
+        Ops.add(v2, "World")
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        v  = "Hello"
+        v2 = v
+        v  = uglify
+        v2 + "World"
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "does not translate `Ops.add(mutated_variable, literal)`" do
+      original_code = cleanup(<<-EOT)
+        v = "Hello"
+        v = f(v)
+        Ops.add(v, "World")
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        v = "Hello"
+        v = f(v)
+        Ops.add(v, "World")
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "does not confuse variables across `def`s" do
+      original_code = cleanup(<<-EOT)
+        def a
+          v = "literal"
+        end
+
+        def b(v)
+          Ops.add(v, "literal")
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        def a
+          v = "literal"
+        end
+
+        def b(v)
+          Ops.add(v, "literal")
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "does not confuse variables across `def self.`s" do
+      original_code = cleanup(<<-EOT)
+        v = 1
+
+        def self.foo(v)
+          Ops.add(v, 1)
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        v = 1
+
+        def self.foo(v)
+          Ops.add(v, 1)
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "does not confuse variables across `module`s" do
+      original_code = cleanup(<<-EOT)
+        module A
+          v = "literal"
+        end
+
+        module B
+          # The assignment is needed to convince Ruby parser that the "v" reference in
+          # the "Ops.add" call later refers to a variable, not a method. This means it
+          # will be parsed as a "lvar" node (which can possibly be nice), not a "send"
+          # node (which can't be nice).
+
+          v = v
+          Ops.add(v, "literal")
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        module A
+          v = "literal"
+        end
+
+        module B
+          # The assignment is needed to convince Ruby parser that the "v" reference in
+          # the "Ops.add" call later refers to a variable, not a method. This means it
+          # will be parsed as a "lvar" node (which can possibly be nice), not a "send"
+          # node (which can't be nice).
+
+          v = v
+          Ops.add(v, "literal")
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "does not confuse variables across `class`s" do
+      original_code = cleanup(<<-EOT)
+        class A
+          v = "literal"
+        end
+
+        class B
+          # The assignment is needed to convince Ruby parser that the "v" reference in
+          # the "Ops.add" call later refers to a variable, not a method. This means it
+          # will be parsed as a "lvar" node (which can possibly be nice), not a "send"
+          # node (which can't be nice).
+
+          v = v
+          Ops.add(v, "literal")
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        class A
+          v = "literal"
+        end
+
+        class B
+          # The assignment is needed to convince Ruby parser that the "v" reference in
+          # the "Ops.add" call later refers to a variable, not a method. This means it
+          # will be parsed as a "lvar" node (which can possibly be nice), not a "send"
+          # node (which can't be nice).
+
+          v = v
+          Ops.add(v, "literal")
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "does not confuse variables across singleton `class`s" do
+      original_code = cleanup(<<-EOT)
+        class << self
+          v = "literal"
+        end
+
+        class << self
+          # The assignment is needed to convince Ruby parser that the "v" reference in
+          # the "Ops.add" call later refers to a variable, not a method. This means it
+          # will be parsed as a "lvar" node (which can possibly be nice), not a "send"
+          # node (which can't be nice).
+
+          v = v
+          Ops.add(v, "literal")
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        class << self
+          v = "literal"
+        end
+
+        class << self
+          # The assignment is needed to convince Ruby parser that the "v" reference in
+          # the "Ops.add" call later refers to a variable, not a method. This means it
+          # will be parsed as a "lvar" node (which can possibly be nice), not a "send"
+          # node (which can't be nice).
+
+          v = v
+          Ops.add(v, "literal")
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+  end
+
+  describe "assignments:" do
+    describe "and-assignment:" do
+      it "manages niceness correctly in presence of `&&=`" do
+        original_code = cleanup(<<-EOT)
+          nice1 = true
+          nice2 = true
+          ugly1 = nil
+          ugly2 = nil
+
+          nice1 &&= true
+          nice2 &&= nil
+          ugly1 &&= true
+          ugly2 &&= nil
+
+          Ops.add(nice1, 1)
+          Ops.add(nice2, 1)
+          Ops.add(ugly1, 1)
+          Ops.add(ugly2, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          nice1 = true
+          nice2 = true
+          ugly1 = nil
+          ugly2 = nil
+
+          nice1 &&= true
+          nice2 &&= nil
+          ugly1 &&= true
+          ugly2 &&= nil
+
+          nice1 + 1
+          Ops.add(nice2, 1)
+          Ops.add(ugly1, 1)
+          Ops.add(ugly2, 1)
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+    end
+
+    describe "or-assignment:" do
+      it "manages niceness correctly in presence of `||=`" do
+        original_code = cleanup(<<-EOT)
+          nice1 = true
+          nice2 = true
+          ugly1 = nil
+          ugly2 = nil
+
+          nice1 ||= true
+          nice2 ||= nil
+          ugly1 ||= true
+          ugly2 ||= nil
+
+          Ops.add(nice1, 1)
+          Ops.add(nice2, 1)
+          Ops.add(ugly1, 1)
+          Ops.add(ugly2, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          nice1 = true
+          nice2 = true
+          ugly1 = nil
+          ugly2 = nil
+
+          nice1 ||= true
+          nice2 ||= nil
+          ugly1 ||= true
+          ugly2 ||= nil
+
+          nice1 + 1
+          nice2 + 1
+          ugly1 + 1
+          Ops.add(ugly2, 1)
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+    end
+  end
+
+  describe "calls preserving niceness:" do
+    it "A localized string literal is nice" do
+      original_code = cleanup(<<-EOT)
+        v = _("Hello")
+        Ops.add(v, "World")
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        v = _("Hello")
+        v + "World"
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    describe "calls generating niceness:" do
+    end
+  end
+
+  describe "translation below top level:" do
+    it "translates a zombie nested in other calls" do
+      original_code = cleanup(<<-EOT)
+        v = 1
+        foo(bar(Ops.add(v, 1), baz))
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        v = 1
+        foo(bar(v + 1, baz))
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+  end
+
+  describe "chained translation:" do
+    it "translates a left-associative  chain of nice zombies" do
+      original_code = cleanup(<<-EOT)
+        Ops.add(Ops.add(1, 2), 3)
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        (1 + 2) + 3
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "translates a right-associative chain of nice zombies" do
+      original_code = cleanup(<<-EOT)
+        Ops.add(1, Ops.add(2, 3))
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        1 + (2 + 3)
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    describe "in case arguments are translated already:" do
+      it "translates `Ops.add` of plus and literal" do
+        original_code = cleanup(<<-EOT)
+          Ops.add("Hello" + " ", "World")
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          ("Hello" + " ") + "World"
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+
+      it "translates `Ops.add` of parenthesized plus and literal" do
+        original_code = cleanup(<<-EOT)
+          Ops.add(("Hello" + " "), "World")
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          ("Hello" + " ") + "World"
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+
+      it "translates `Ops.add` of literal and plus" do
+        original_code = cleanup(<<-EOT)
+          Ops.add("Hello", " " + "World")
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          "Hello" + (" " + "World")
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+    end
+  end
+
+  describe "if:" do
+    it "translates the `then` body of an `if` statement" do
+      original_code = cleanup(<<-EOT)
+        if cond
+          Ops.add(1, 1)
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        if cond
+          1 + 1
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "translates the `then` body of an `unless` statement" do
+      original_code = cleanup(<<-EOT)
+        unless cond
+          Ops.add(1, 1)
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        unless cond
+          1 + 1
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "It translates both branches of an `if` statement, independently of each other" do
+      original_code = cleanup(<<-EOT)
+        v = 1
+        if cond
+          Ops.add(v, 1)
+          v = nil
+        else
+          Ops.add(1, v)
+          v = nil
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        v = 1
+        if cond
+          v + 1
+          v = nil
+        else
+          1 + v
+          v = nil
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "The condition also contributes to the data state" do
+      original_code = cleanup(<<-EOT)
+        if cond(v = 1)
+          Ops.add(v, 1)
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        if cond(v = 1)
+          v + 1
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    describe "a variable is not nice after its niceness was invalidated by an `if`:" do
+      it "Plain `if`" do
+        original_code = cleanup(<<-EOT)
+          v = 1
+          if cond
+            v = nil
+          end
+          Ops.add(v, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          v = 1
+          if cond
+            v = nil
+          end
+          Ops.add(v, 1)
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+
+      it "Trailing `if`" do
+        original_code = cleanup(<<-EOT)
+          v = 1
+          v = nil if cond
+          Ops.add(v, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          v = 1
+          v = nil if cond
+          Ops.add(v, 1)
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+
+      it "Plain `unless`" do
+        original_code = cleanup(<<-EOT)
+          v = 1
+          unless cond
+            v = nil
+          end
+          Ops.add(v, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          v = 1
+          unless cond
+            v = nil
+          end
+          Ops.add(v, 1)
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+
+      it "Trailing `unless`" do
+        original_code = cleanup(<<-EOT)
+          v = 1
+          v = nil unless cond
+          Ops.add(v, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          v = 1
+          v = nil unless cond
+          Ops.add(v, 1)
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+    end
+
+    describe "resuming with a clean slate after an `if`:" do
+      it "It translates zombies whose arguments were found nice after an `if`" do
+        original_code = cleanup(<<-EOT)
+          if cond
+             v = nil
+          end
+          v = 1
+          Ops.add(v, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          if cond
+             v = nil
+          end
+          v = 1
+          v + 1
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+    end
+  end
+
+  describe "case:" do
+    it "translates the `when` body of a `case` statement" do
+      original_code = cleanup(<<-EOT)
+        case expr
+          when 1
+            Ops.add(1, 1)
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        case expr
+          when 1
+            1 + 1
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "It translates all branches of a `case` statement, independently of each other" do
+      original_code = cleanup(<<-EOT)
+        v = 1
+        case expr
+          when 1
+            Ops.add(v, 1)
+            v = nil
+          when 2
+            Ops.add(v, 2)
+            v = nil
+          else
+            Ops.add(1, v)
+            v = nil
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        v = 1
+        case expr
+          when 1
+            v + 1
+            v = nil
+          when 2
+            v + 2
+            v = nil
+          else
+            1 + v
+            v = nil
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "The expression also contributes to the data state" do
+      original_code = cleanup(<<-EOT)
+        case v = 1
+          when 1
+            Ops.add(v, 1)
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        case v = 1
+          when 1
+            v + 1
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "The test also contributes to the data state" do
+      original_code = cleanup(<<-EOT)
+        case expr
+          when v = 1
+            Ops.add(v, 1)
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        case expr
+          when v = 1
+            v + 1
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    describe "a variable is not nice after its niceness was invalidated by a `case`:" do
+      it "The test also contributes to the data state" do
+        original_code = cleanup(<<-EOT)
+          v = 1
+          case expr
+            when 1
+              v = nil
+          end
+          Ops.add(v, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          v = 1
+          case expr
+            when 1
+              v = nil
+          end
+          Ops.add(v, 1)
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+    end
+
+    describe "resuming with a clean slate after a `case`:" do
+      it "It translates zombies whose arguments were found nice after a `case`" do
+        original_code = cleanup(<<-EOT)
+          case expr
+            when 1
+              v = nil
+          end
+          v = 1
+          Ops.add(v, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          case expr
+            when 1
+              v = nil
+          end
+          v = 1
+          v + 1
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+    end
+  end
+
+  describe "loops:" do
+    describe "while and until:" do
+      it "does not translate anything in the outer scope that contains a `while`" do
+        original_code = cleanup(<<-EOT)
+          v = 1
+          while Ops.add(v, 1)
+            Ops.add(1, 1)
+          end
+          Ops.add(v, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          v = 1
+          while Ops.add(v, 1)
+            Ops.add(1, 1)
+          end
+          Ops.add(v, 1)
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+
+      it "does not translate anything in the outer scope that contains an `until`" do
+        original_code = cleanup(<<-EOT)
+          v = 1
+          until Ops.add(v, 1)
+            Ops.add(1, 1)
+          end
+          Ops.add(v, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          v = 1
+          until Ops.add(v, 1)
+            Ops.add(1, 1)
+          end
+          Ops.add(v, 1)
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+
+      it "can continue processing after a `while`" do
+        original_code = cleanup(<<-EOT)
+          while cond
+            foo
+          end
+          v = 1
+          Ops.add(v, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          while cond
+            foo
+          end
+          v = 1
+          v + 1
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+
+      it "can continue processing after an `until`" do
+        original_code = cleanup(<<-EOT)
+          until cond
+            foo
+          end
+          v = 1
+          Ops.add(v, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          until cond
+            foo
+          end
+          v = 1
+          v + 1
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+
+      it "can parse both the syntactic and semantic post-condition" do
+        original_code = cleanup(<<-EOT)
+          body_runs_after_condition while cond
+          body_runs_after_condition until cond
+
+          begin
+            body_runs_before_condition
+          end while cond
+
+          begin
+            body_runs_before_condition
+          end until cond
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          body_runs_after_condition while cond
+          body_runs_after_condition until cond
+
+          begin
+            body_runs_before_condition
+          end while cond
+
+          begin
+            body_runs_before_condition
+          end until cond
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+    end
+
+    describe "for:" do
+      it "does not translate inside a `for` and resumes with a clean slate" do
+        original_code = cleanup(<<-EOT)
+          v = 1
+          v = Ops.add(v, 1)
+
+          for i in [1, 2, 3]
+            v = Ops.add(v, 1)
+            v = uglify
+          end
+
+          v = Ops.add(v, 1)
+          w = 1
+          w = Ops.add(w, 1)
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          v = 1
+          v = v + 1
+
+          for i in [1, 2, 3]
+            v = Ops.add(v, 1)
+            v = uglify
+          end
+
+          v = Ops.add(v, 1)
+          w = 1
+          w = w + 1
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+    end
+  end
+
+  describe "exceptions:" do
+    it "translates the parts, joining else, rescue separately" do
+      original_code = cleanup(<<-EOT)
+        def foo
+          v = 1
+          Ops.add(v, 1)
+        rescue
+          w = 1
+          Ops.add(w, 1)
+          v = nil
+        rescue
+          Ops.add(w, 1)
+        else
+          Ops.add(v, 1)
+        end
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        def foo
+          v = 1
+          v + 1
+        rescue
+          w = 1
+          w + 1
+          v = nil
+        rescue
+          Ops.add(w, 1)
+        else
+          v + 1
+        end
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    describe "skipping code:" do
+      it "does not translate code that depends on niceness skipped via an exception" do
+        original_code = cleanup(<<-EOT)
+          def a_problem
+            v = nil
+            w = 1 / 0
+            v = 1
+          rescue
+            puts "Oops", Ops.add(v, 1)
+          end
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          def a_problem
+            v = nil
+            w = 1 / 0
+            v = 1
+          rescue
+            puts "Oops", Ops.add(v, 1)
+          end
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+    end
+
+    describe "exception syntax:" do
+      it "can parse the syntactic variants of exception handling" do
+        original_code = cleanup(<<-EOT)
+          begin
+            foo
+            raise "LOL"
+            foo
+          rescue Error
+            foo
+          rescue Bug, Blunder => b
+            foo
+          rescue => e
+            foo
+          rescue
+            foo
+          ensure
+            foo
+          end
+          yast rescue nil
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          begin
+            foo
+            raise "LOL"
+            foo
+          rescue Error
+            foo
+          rescue Bug, Blunder => b
+            foo
+          rescue => e
+            foo
+          rescue
+            foo
+          ensure
+            foo
+          end
+          yast rescue nil
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+    end
+
+    describe "retry:" do
+      it "does not translate a begin-body when a rescue contains a retry" do
+        original_code = cleanup(<<-EOT)
+          def foo
+            v = 1
+            begin
+              Ops.add(v, 1)
+              maybe_raise
+            rescue
+              v = nil
+              retry
+            end
+          end
+        EOT
+
+        translated_code = cleanup(<<-EOT)
+          def foo
+            v = 1
+            begin
+              Ops.add(v, 1)
+              maybe_raise
+            rescue
+              v = nil
+              retry
+            end
+          end
+        EOT
+
+        expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+      end
+    end
+  end
+
+  describe "blocks:" do
+    it "does not translate inside a block and resumes with a clean slate" do
+      original_code = cleanup(<<-EOT)
+        v = 1
+        v = Ops.add(v, 1)
+
+        2.times do
+          v = Ops.add(v, 1)
+          v = uglify
+        end
+
+        v = Ops.add(v, 1)
+        w = 1
+        w = Ops.add(w, 1)
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        v = 1
+        v = v + 1
+
+        2.times do
+          v = Ops.add(v, 1)
+          v = uglify
+        end
+
+        v = Ops.add(v, 1)
+        w = 1
+        w = w + 1
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+  end
+
+  describe "formatting:" do
+    it "does not translate `Ops.add` if any argument has a comment" do
+      original_code = cleanup(<<-EOT)
+        Ops.add(
+          "Hello",
+          # foo
+          "World"
+        )
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+        Ops.add(
+          "Hello",
+          # foo
+          "World"
+        )
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+  end
+
+  describe "templates:" do
+    it "It translates" do
+      original_code = cleanup(<<-EOT)
+
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+
+    it "It does not translate" do
+      original_code = cleanup(<<-EOT)
+
+      EOT
+
+      translated_code = cleanup(<<-EOT)
+
+      EOT
+
+      expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
+    end
+  end
+end