Refactor AST assembler to be stateful (needed by #7)

lib/cucumber/ast/assembler.js

@@ -1,24 +1,35 @@
 var Assembler = function(features) {
+  var currentFeature, currentScenarioOrBackground, currentStep;
+
   var self = {
+    setCurrentFeature: function setCurrentFeature(feature) {
+      currentFeature = feature;
+      self.setCurrentScenarioOrBackground(undefined);
+    },
+
     getCurrentFeature: function getCurrentFeature() {
-      return features.getLastFeature();
+      return currentFeature;
+    },
+
+    setCurrentScenarioOrBackground: function setCurrentScenarioOrBackground(scenarioOrBackground) {
+      currentScenarioOrBackground = scenarioOrBackground;
+      self.setCurrentStep(undefined);
     },
 
     getCurrentScenarioOrBackground: function getCurrentScenarioOrBackground() {
-      var currentFeature       = self.getCurrentFeature();
-      var scenarioOrBackground = currentFeature.getLastScenario();
-      if (!scenarioOrBackground)
-        scenarioOrBackground = currentFeature.getBackground();
-      return scenarioOrBackground;
+      return currentScenarioOrBackground;
+    },
+
+    setCurrentStep: function setCurrentStep(step) {
+      currentStep = step;
     },
 
     getCurrentStep: function getCurrentStep() {
-      var currentScenarioOrBackground = self.getCurrentScenarioOrBackground();
-      var lastStep                    = currentScenarioOrBackground.getLastStep();
-      return lastStep;
+      return currentStep;
     },
 
     insertBackground: function insertBackground(background) {
+      self.setCurrentScenarioOrBackground(background);
       var currentFeature = self.getCurrentFeature();
       currentFeature.addBackground(background);
     },
@@ -34,15 +45,18 @@ var Assembler = function(features) {
     },
 
     insertFeature: function insertFeature(feature) {
+      self.setCurrentFeature(feature);
       features.addFeature(feature);
     },
 
     insertScenario: function insertScenario(scenario) {
+      self.setCurrentScenarioOrBackground(scenario);
       var currentFeature = self.getCurrentFeature();
       currentFeature.addScenario(scenario);
     },
 
     insertStep: function insertStep(step) {
+      self.setCurrentStep(step);
       var currentScenarioOrBackground = self.getCurrentScenarioOrBackground();
       currentScenarioOrBackground.addStep(step);
     }

spec/cucumber/ast/assembler_spec.js

@@ -9,95 +9,70 @@ describe("Cucumber.Ast.Assembler", function() {
     assembler = Cucumber.Ast.Assembler(features);
   });
 
-  describe("getCurrentFeature()", function() {
-    var lastFeature;
+  describe("setCurrentFeature()", function() {
+    var currentFeature;
 
     beforeEach(function() {
-      lastFeature = createSpy("Last recorded feature");
-      spyOnStub(features, 'getLastFeature').andReturn(lastFeature);
-    });
-
-    it("gets the last feature from the root features", function() {
-      assembler.getCurrentFeature();
-      expect(features.getLastFeature).toHaveBeenCalled();
+      currentFeature = createSpy("current feature");
+      spyOn(assembler, 'setCurrentScenarioOrBackground');
     });
 
-    it("returns the last feature", function() {
-      expect(assembler.getCurrentFeature()).toEqual(lastFeature);
+    it("unsets the current scenario", function() {
+      assembler.setCurrentFeature(currentFeature);
+      expect(assembler.setCurrentScenarioOrBackground).toHaveBeenCalledWith(undefined);
     });
   });
 
-  describe("getCurrentScenarioOrBackground()", function() {
+  describe("getCurrentFeature() [setCurrentFeature()]", function() {
     var currentFeature;
 
     beforeEach(function() {
-      currentFeature = createSpyWithStubs("Current feature", {getLastScenario: undefined, getBackground: undefined});
-      spyOn(assembler, 'getCurrentFeature').andReturn(currentFeature);
-    });
-
-    it("gets the current feature", function() {
-      assembler.getCurrentScenarioOrBackground();
-      expect(assembler.getCurrentFeature).toHaveBeenCalled();
+      currentFeature = createSpy("current feature");
     });
 
-    it("asks the current feature for its last scenario", function() {
-      assembler.getCurrentScenarioOrBackground();
-      expect(currentFeature.getLastScenario).toHaveBeenCalled();
+    it("returns the current feature", function() {
+      assembler.setCurrentFeature(currentFeature);
+      expect(assembler.getCurrentFeature()).toBe(currentFeature);
     });
+  });
 
-    describe("when there is a last scenario", function() {
-      var lastScenario;
-
-      beforeEach(function() {
-        lastScenario = createSpy("Last scenario of the feature");
-        currentFeature.getLastScenario.andReturn(lastScenario);
-      });
+  describe("setCurrentScenarioOrBackground()", function() {
+    var currentScenarioOrBackground;
 
-      it("returns the last scenario", function() {
-        expect(assembler.getCurrentScenarioOrBackground()).toBe(lastScenario);
-      });
+    beforeEach(function() {
+      currentScenarioOrBackground = createSpy("current scenario or background");
+      spyOn(assembler, 'setCurrentStep');
     });
 
-    describe("when there is no last scenario", function() {
-      var background;
-
-      beforeEach(function() {
-        background = createSpy("background");
-        spyOnStub(currentFeature, 'getBackground').andReturn(background);
-      });
-
-      it("gets the background", function() {
-        assembler.getCurrentScenarioOrBackground();
-        expect(currentFeature.getBackground).toHaveBeenCalled();
-      });
-
-      it("returns the background", function() {
-        expect(assembler.getCurrentScenarioOrBackground()).toBe(background);
-      });
+    it("unsets the current step", function() {
+      assembler.setCurrentScenarioOrBackground(currentScenarioOrBackground);
+      expect(assembler.setCurrentStep).toHaveBeenCalledWith(undefined);
     });
   });
 
-  describe("getCurrentStep()", function() {
-    var currentScenario, lastStep;
+  describe("getCurrentScenarioOrBackground() [setCurrentScenarioOrBackground()]", function() {
+    var currentScenarioOrBackground;
 
     beforeEach(function() {
-      lastStep = createSpy("Last step of the scenario");
-      currentScenario = createSpyWithStubs("Current scenario", {getLastStep: lastStep});
-      spyOn(assembler, 'getCurrentScenarioOrBackground').andReturn(currentScenario);
+      currentScenarioOrBackground = createSpy("current scenario or background");
     });
 
-    it("gets the current scenario or background", function() {
-      assembler.getCurrentStep();
-      expect(assembler.getCurrentScenarioOrBackground).toHaveBeenCalled();
+    it("returns the current scenario or background", function() {
+      assembler.setCurrentScenarioOrBackground(currentScenarioOrBackground);
+      expect(assembler.getCurrentScenarioOrBackground()).toBe(currentScenarioOrBackground);
     });
+  });
+
+  describe("getCurrentStep() [setCurrentStep()]", function() {
+    var currentStep;
 
-    it("asks the current scenario or background for its last step", function() {
-      assembler.getCurrentStep();
-      expect(currentScenario.getLastStep).toHaveBeenCalled();
+    beforeEach(function() {
+      currentStep = createSpy("current step");
     });
 
-    it("returns the last step", function() {
-      expect(assembler.getCurrentStep()).toBe(lastStep);
+    it("returns the current step", function() {
+      assembler.setCurrentStep(currentStep);
+      expect(assembler.getCurrentStep()).toBe(currentStep);
     });
   });
 
@@ -108,6 +83,12 @@ describe("Cucumber.Ast.Assembler", function() {
       background     = createSpy("background");
       currentFeature = createSpyWithStubs("current feature", {addBackground: null});
       spyOn(assembler, 'getCurrentFeature').andReturn(currentFeature);
+      spyOn(assembler, 'setCurrentScenarioOrBackground');
+    });
+
+    it("sets the background as the current background", function() {
+      assembler.insertBackground(background);
+      expect(assembler.setCurrentScenarioOrBackground).toHaveBeenCalledWith(background);
     });
 
     it("gets the current feature", function() {
@@ -127,6 +108,12 @@ describe("Cucumber.Ast.Assembler", function() {
     beforeEach(function() {
       feature = createSpy("feature");
       spyOnStub(features, 'addFeature');
+      spyOn(assembler, 'setCurrentFeature');
+    });
+
+    it("sets the feature as the current feature", function() {
+      assembler.insertFeature(feature);
+      expect(assembler.setCurrentFeature).toHaveBeenCalledWith(feature);
     });
 
     it("adds the feature to the root features", function() {
@@ -182,6 +169,12 @@ describe("Cucumber.Ast.Assembler", function() {
       scenario     = createSpy("scenario");
       currentFeature = createSpyWithStubs("current feature", {addScenario: null});
       spyOn(assembler, 'getCurrentFeature').andReturn(currentFeature);
+      spyOn(assembler, 'setCurrentScenarioOrBackground');
+    });
+
+    it("sets the scenario as the current scenario", function() {
+      assembler.insertScenario(scenario);
+      expect(assembler.setCurrentScenarioOrBackground).toHaveBeenCalledWith(scenario);
     });
 
     it("gets the current feature", function() {
@@ -202,6 +195,12 @@ describe("Cucumber.Ast.Assembler", function() {
       step                        = createSpy("step");
       currentScenarioOrBackground = createSpyWithStubs("current scenario or background", {addStep: null});
       spyOn(assembler, 'getCurrentScenarioOrBackground').andReturn(currentScenarioOrBackground);
+      spyOn(assembler, 'setCurrentStep');
+    });
+
+    it("sets the step as the current step", function() {
+      assembler.insertStep(step);
+      expect(assembler.setCurrentStep).toHaveBeenCalledWith(step);
     });
 
     it("gets the current scenario or background", function() {