public IExecutionStep CreatePlan(Step step, FixtureLibrary library)
 {
     return new SilentAction("Grammar", _position, _action, step)
     {
         Subject = Key
     };
 }

 public void CreatePlan(FixtureLibrary library)
 {
     performAction(() =>
     {
         Plan = Specification.CreatePlan(library);
     });
 }

 public GrammarStructure ToStructure(FixtureLibrary library)
 {
     return new SetVerification(_labelName, _leafName, cells())
     {
         Ordered = Ordered
     };
 }

 public OutlineTreeBuilder(Test test, FixtureLibrary library, IOutlineConfigurer configurer)
 {
     var workspace = test.GetWorkspace();
     _library = library.Filter(workspace.CreateFixtureFilter().Matches);
     _test = test;
     _configurer = configurer;
 }

 public IExecutionStep CreatePlan(Step step, FixtureLibrary library, bool inTable = false)
 {
     return new SilentAction("Grammar", Position, _action, step)
     {
         Subject = Key
     };
 }

        public void copies_grammars()
        {
            const string fixtureKey = "a key";

            var lib = new FixtureLibrary();
            var original = new FixtureModel(fixtureKey);
            lib.Models[fixtureKey] = original;

            original.AddGrammar(new Sentence { key = "sentence", format = "a format"});

            var overrides = new FixtureLibrary();
            var overriden = new FixtureModel(fixtureKey);
            overrides.Models[fixtureKey] = overriden;

            var result = lib.ApplyOverrides(overrides);

            result.Models.Count.ShouldBe(1);

            var fixture = result.Models[fixtureKey];
            ReferenceEquals(fixture, overrides.Models[fixtureKey]).ShouldBeFalse();
            fixture.key.ShouldBe(fixtureKey);

            fixture.grammars.Length.ShouldBe(1);

            var sentence = fixture.grammars[0] as Sentence;
            sentence.key.ShouldBe("sentence");
            sentence.format.ShouldBe("a format");
        }

        public TestEditorTag(FixtureLibrary library)
            : base("div")
        {
            AddClass("main");
            Add("h2").AddClass(HtmlClasses.TEST_NAME);
            Id("testEditor");

            AddClass(HtmlClasses.TEST_EDITOR);

            _container = Add("div").AddClasses("container", HtmlClasses.SECTION, "test-editor");

            FixtureGraph fixture = library.BuildTopLevelGraph();

            HtmlTag holder = new HolderTag(fixture).AddClass("top-level-holder");
            holder.Children.Last().Render(false);

            Container
                .MetaData(GrammarConstants.LEAF_NAME, GrammarConstants.TEST)
                .MetaData(GrammarConstants.FIXTURE, GrammarConstants.TEST)
                .MetaData(GrammarConstants.SELECTION_MODE, SelectionMode.OneOrMore.ToString())
                .Append(holder)
                .Append(new HtmlTag("hr"));

            Container.ActionLink(fixture.Policies.AddGrammarText, GrammarConstants.ADD_SECTION_ACTIVATOR);
            Container.Append(new GrammarSelector(fixture).Build());
        }

        public CompositeExecution CreatePlan(FixtureLibrary library)
        {
            var fixture = library.Fixtures[Key];

            if (id.IsEmpty()) id = Guid.NewGuid().ToString();

            return CreatePlan(library, fixture);
        }

        public GrammarStructure ToStructure(FixtureLibrary library)
        {
            if (library == null) throw new ArgumentNullException("library");

            Cell[] cells = GetCells().Select(x => x.ToInputCell()).ToArray();

            return new Sentence(Template, cells);
        }

        public FixtureLibrary Build(ITestContext context)
        {
            _library = new FixtureLibrary();

            context.VisitFixtures(this);

            return _library;
        }

 public void should_have_a_label()
 {
     var fixture = new FactFixture();
     var grammar = fixture["True"];
     var fixtureLibrary = new FixtureLibrary();
     var sentence = grammar.ToStructure(fixtureLibrary) as Sentence;
     sentence.PartCount.ShouldEqual(1);
     sentence.Parts[0].ShouldBeOfType<Label>().Text.ShouldEqual("This is true");
 }

 public static void PostProcessAll(IEnumerable<Specification> specs, FixtureLibrary library)
 {
     foreach (var spec in specs)
     {
         spec.ClearErrors();
         var processor = new SpecificationPostProcessor(library, spec);
         processor.Validate();
     }
 }

        public void can_create_screen_for_fixturelibrary()
        {
            var library = new FixtureLibrary();
            var subject = _objectLocator.BuildSubject(library).ShouldBeOfType<FixtureNodeSubject>();

            subject.Subject.ShouldBeTheSameAs(library);
            var presenter = subject.CreateScreen(factory).ShouldBeOfType<FixtureNodePresenter>();
            presenter.Subject.ShouldBeTheSameAs(library);
        }

        private void buildFixtureSelectors(FixtureLibrary library, Cache<string, NamespaceSelector> namespaces, Cache<string, FixtureSelector> fixtures)
        {
            library.AllFixtures.Each(x =>
            {
                var item = new FixtureSelector(x);
                fixtures[x.Name] = item;

                namespaces[x.Namespace].Add(item);
            });
        }

        public override void ResolveDependencies(FixtureLibrary library)
        {
            var embeddedKey = fixture.key;
            if (library.Models.Has(embeddedKey))
            {
                fixture = library.Models[embeddedKey];
            }

            
        }

        public JavaScriptTestFile Fixtures(Action<FixtureRegistry> configure)
        {
            _library = FixtureLibrary.For(configure);

            var writer = new GrammarWriter(_library);
            HtmlTag templates = writer.Build();
            Add(templates);

            return this;
        }

        // TODO -- if an error bubbles up, the SpecificationEngine should mark its runner
        //         as Invalid
        public static StepthroughExecutor Start(ISystem system, Specification specification, IResultObserver observer, IUserInterfaceObserver uiObserver, FixtureLibrary library)
        {
            var request = new SpecExecutionRequest(specification, observer);
            request.CreatePlan(library);

            // Got to watch because this can error out
            var execution = system.CreateContext();

            return new StepthroughExecutor(execution, request, uiObserver);
        }

        public JavaScriptTestFile Fixtures(FixtureLibrary fixtureLibrary)
        {
            _library = fixtureLibrary;

            var writer = new GrammarWriter(_library);
            HtmlTag templates = writer.Build();
            Add(templates);

            return this;
        }

        public void SetUp()
        {
            theTest = new Test("something");
            theLibrary = new FixtureLibrary();

            nodeBuilder = MockRepository.GenerateMock<IOutlineConfigurer>();

            treeBuilder = new OutlineTreeBuilder(theTest, theLibrary, nodeBuilder);

            theContextIs();
        }

        public UsageGraph(FixtureLibrary library, IUsageGraphListener listener)
        {
            _library = library;
            _listener = listener;

            _fixtures.OnMissing = name =>
            {
                var fixture = library.FixtureFor(name);
                return new FixtureUsage(fixture);
            };
        }