public GrammarModel Compile(Fixture fixture, CellHandling cells)
{
return new Sentence
{
format = _label
};
}
public Cell BuildCell(CellHandling handling, Fixture fixture)
{
var cell = new Cell(handling, Name, _columnType);
CellModifications.Apply(cell);
return cell;
}
public static CompiledFixture CreateCompiledFixture(CellHandling cellHandling, Type type)
{
try
{
var fixture = Activator.CreateInstance(type) as Fixture;
FixtureCache[type] = fixture;
return new CompiledFixture
{
Fixture = fixture,
Model = fixture.Compile(cellHandling)
};
}
catch (Exception e)
{
var fixture = new InvalidFixture(type, e);
var model = fixture.Compile(cellHandling);
model.implementation = type.FullName;
return new CompiledFixture
{
Fixture = fixture,
Model = model
};
}
}
public Cell BuildCell(CellHandling handling, Fixture fixture)
{
Cell = new Cell(handling, _key, typeof(T));
Customize.Apply(Cell);
return(Cell);
}
protected override IEnumerable <Cell> buildCells(CellHandling cellHandling, Fixture fixture)
{
_cell = new Cell(cellHandling, _accessor.Name, _accessor.PropertyType);
CellModifications.Apply(_cell);
return(new[] { _cell });
}
public override IReaderMode Read(int indention, string text)
{
if (!text.IsTableLine())
{
return(null);
}
var values = text.ToTableValues();
if (_table.cells == null)
{
_table.cells = values
.Skip(1)
.Select(x => new Cell(CellHandling.Basic(), x, typeof(string)))
.ToArray();
return(this);
}
var target = values.First();
var rest = values.Skip(1).Take(_table.cells.Length).ToList();
if (!rest.Any())
{
return(null);
}
rest.Each((value, i) =>
{
var cell = _table.cells[i];
applyValue(target, cell, value);
});
return(this);
}
protected override IEnumerable <Cell> buildCells(CellHandling cellHandling, Fixture fixture)
{
_cellHandling = cellHandling;
_cell = new Cell(cellHandling, _key, typeof(T));
return(new [] { _cell });
}
protected override IEnumerable <Cell> buildCells(CellHandling cellHandling, Fixture fixture)
{
_cell = Cell.For(cellHandling, _accessor, fixture);
CellModifications.Apply(_cell);
return(new[] { _cell });
}
public override FixtureModel Compile(CellHandling conversions)
{
var model = new FixtureModel(Key);
model.AddError(_error);
return model;
}
public void embedded_fixture_exists_in_code_but_has_overrides()
{
writeFile("Master", @"
## MoveAround
### Move Around
embeds Actions
");
writeFile("Actions", @"
## GoLeft
### Go left
## GoBack
### Go back
");
theSystemFixtures.Models["Actions"] = new ActionsFixture().Compile(CellHandling.Basic());
var grammar = theCombinedFixtures.Models["Master"]
.FindGrammar("MoveAround").ShouldBeOfType <EmbeddedSection>();
grammar.fixture.FindGrammar("GoLeft").ShouldBeOfType <Sentence>()
.format.ShouldBe("Go left");
grammar.fixture.FindGrammar("GoBack").ShouldBeOfType <Sentence>()
.format.ShouldBe("Go back");
grammar.fixture.FindGrammar("GoRight").ShouldNotBeNull();
grammar.fixture.FindGrammar("GoForward").ShouldNotBeNull();
}
public void no_hidden_grammars_in_fixture_model()
{
var compiledFixture = FixtureLibrary.CreateCompiledFixture(CellHandling.Basic(), typeof(TopicFolderFixture));
compiledFixture.Model.grammars.OrderBy(x => x.key).Select(x => x.key)
.ShouldHaveTheSameElementsAs("AllTopicsShouldBe", "CheckTopic", "ForFile", "TheTopicsAre", "TODO", "WriteFile");
}
public Cell BuildCell(CellHandling handling, Fixture fixture)
{
var cell = new Cell(handling, _accessor.Name, _accessor.PropertyType);
CellModifications.Apply(cell);
return cell;
}
public GrammarModel Compile(Fixture fixture, CellHandling cells)
{
return(new Sentence
{
format = _label
});
}
public static FixtureLibrary CreateForAppDomain(CellHandling cellHandling)
{
var currentDomain = AppDomain.CurrentDomain;
var assemPath = currentDomain.BaseDirectory;
var binPath = currentDomain.SetupInformation.PrivateBinPath;
if (binPath.IsNotEmpty())
{
assemPath = assemPath.AppendPath(binPath);
}
var fixtures = AssembliesFromPath(assemPath, referencesStoryteller)
.SelectMany(FixtureTypesFor)
.Select(
type => CreateCompiledFixture(cellHandling, type));
var library = new FixtureLibrary();
fixtures.Each(x =>
{
library.Fixtures[x.Fixture.Key] = x.Fixture;
library.Models[x.Fixture.Key] = x.Model;
});
return(library);
}
public static CompiledFixture CreateCompiledFixture(CellHandling cellHandling, Type type)
{
try
{
var fixture = Activator.CreateInstance(type) as Fixture;
FixtureCache[type] = fixture;
return(new CompiledFixture
{
Fixture = fixture,
Model = fixture.Compile(cellHandling)
});
}
catch (Exception e)
{
var fixture = new InvalidFixture(type, e);
var model = fixture.Compile(cellHandling);
model.implementation = type.FullName;
return(new CompiledFixture
{
Fixture = fixture,
Model = model
});
}
}
public GrammarModel Compile(Fixture fixture, CellHandling cells)
{
return(new Sentence
{
format = _method.DeriveFormat()
});
}
public void build_cells()
{
var cells = comparer.BuildCells(CellHandling.Basic(), new Fixture());
cells.Select(x => x.Key).ShouldHaveTheSameElementsAs("City", "Address1", "DistanceFromOffice");
cells.Select(x => x.Type).ShouldHaveTheSameElementsAs(typeof(string), typeof(string), typeof(double));
}
public Cell CompileCell(CellHandling cellHandling, Fixture fixture)
{
_cell = Cell.For(cellHandling, _property, fixture);
_cell.result = true;
return(_cell);
}
public GrammarModel Compile(Fixture fixture, CellHandling cells)
{
// TODO -- write a UT to pin this behavior down
// This is important to get the right lists, *use* the lists
// from the inner fixture here.
return _inner.Compile(_innerFixture, cells);
}
public void invoke_with_out_parameters_happy_path()
{
var age = 0;
double percentAwake = 0;
var target = new Target();
var method = ReflectionHelper.GetMethod <Target>(x => x.GoOutput(null, out age, out percentAwake));
var values = new StepValues(method.Name);
values.Store("name", "Grace Potter");
values.Store("age", 5);
values.Store("percentAwake", .5);
var invocation = MethodInvocation.For(method, target);
invocation.Compile(target, CellHandling.Basic());
var results = invocation.Invoke(values).ToArray();
results.ShouldHaveTheSameElementsAs(
new CellResult("age", ResultStatus.success),
new CellResult("percentAwake", ResultStatus.success)
);
}
private void roundTrip <T>() where T : Fixture, new()
{
var fixture = new T();
var model = fixture.Compile(CellHandling.Basic());
var markdown1 = FixtureWriter.Write(model);
Console.WriteLine("Fixture " + typeof(T).Name);
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(markdown1);
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine();
Console.WriteLine();
var model2 = FixtureReader.ReadFrom(markdown1);
var markdown2 = FixtureWriter.Write(model2);
var grammars1 = model.grammars.Where(x => x.key != "TODO").OrderBy(x => x.key).Select(x => x.key);
var grammars2 = model2.grammars.OrderBy(x => x.key).Select(x => x.key);
grammars2.ShouldHaveTheSameElementsAs(grammars1.ToArray());
markdown2.ShouldBe(markdown1);
}
public Cell ApplyOverrides(Cell over)
{
var cell = new Cell(CellHandling.Basic(), Key, Type);
cell.OptionListName = OptionListName;
cell.Position = Position;
if (over == null)
{
cell.DefaultValue = DefaultValue;
cell.result = result;
cell.editor = editor;
cell.header = header;
cell.options = options?.Select(x => x.Copy()).ToArray();
return(cell);
}
cell.DefaultValue = over.DefaultValue.IsNotEmpty() ? over.DefaultValue : DefaultValue;
cell.result = over.result.IsNotEmpty() ? over.result : result;
cell.editor = over.editor.IsNotEmpty() ? over.editor : editor;
cell.header = over.header.IsNotEmpty() ? over.header : header;
cell.options = over.options != null
? over.options?.Select(x => x.Copy()).ToArray()
: options?.Select(x => x.Copy()).ToArray();
return(cell);
}
public static Cell For(CellHandling cells, ParameterInfo parameter, Fixture fixture)
{
var isOutput = false;
var type = parameter.ParameterType;
if (parameter.IsOut)
{
type = type.GetElementType();
isOutput = true;
}
if (type.Closes(typeof(Task <>)))
{
type = type.GetGenericArguments().Single();
}
var cell = new Cell(cells, parameter.Name, type)
{
result = isOutput, Position = parameter.Position
};
parameter.ForAttribute <ModifyCellAttribute>(x => x.Modify(cell));
type.ForAttribute <ModifyCellAttribute>(x => x.Modify(cell));
if (parameter.HasDefaultValue)
{
cell.DefaultValue = parameter.DefaultValue?.ToString() ?? "NULL";
}
cell.readLists(cells, fixture);
return(cell);
}
protected override void configureCellHandling(CellHandling handling)
{
var directory = AppContext.BaseDirectory;
while (Path.GetFileName(directory) != "ReduxSamples")
{
directory = directory.ParentDirectory();
}
var jsFile = directory.AppendPath("reduxharness.js");
Console.WriteLine("Copying the reduxharness.js file to " + directory);
var source = directory.AppendPath("..", "StorytellerRunner", "reduxharness.js");
File.Copy(source, jsFile, true);
var harnessPath = directory.AppendPath("harness.htm");
if (!File.Exists(harnessPath))
{
var doc = new HtmlDocument();
var href = "file://" + jsFile;
doc.Head.Add("script").Attr("src", href);
Console.WriteLine("Writing the harness file to " + harnessPath);
doc.WriteToFile(harnessPath);
}
var url = "file://" + harnessPath;
handling.Extensions.Add(new ReduxSagaExtension(url));
}
public override IReaderMode Read(int indention, string text)
{
if (!text.IsTableLine())
{
return(null);
}
var values = text.ToTableValues();
if (_template == null)
{
_template = values;
return(this);
}
var cell = new Cell(CellHandling.Basic(), null, typeof(string));
values.Each((value, i) =>
{
applyValue(_template[i], cell, value);
});
_sentence.AddCell(cell);
return(this);
}
public Cell CompileCell(CellHandling cellHandling, Fixture fixture)
{
_cell = Cell.For(cellHandling, _property, fixture);
_cell.output = true;
return _cell;
}
public void get_cell()
{
Cell cell = _matchCity.As <IColumnMatch>().BuildCell(CellHandling.Basic(), new Fixture());
cell.Key.ShouldBe("City");
cell.Type.ShouldBe(typeof(string));
}
protected override IEnumerable <Cell> buildCells(CellHandling cellHandling, Fixture fixture)
{
_cell = new Cell(cellHandling, _key, typeof(TInput));
_cell.DefaultValue = DefaultValue;
return(new[] { _cell });
}
public GrammarModel Compile(Fixture fixture, CellHandling cells)
{
// TODO -- write a UT to pin this behavior down
// This is important to get the right lists, *use* the lists
// from the inner fixture here.
return(_inner.Compile(_innerFixture, cells));
}
public void select_format_by_names()
{
var grammar = ActionMethodGrammar.Create(x => x.FancyGo(null, 0, 0), theTarget);
var model = grammar.Compile(new Fixture(), CellHandling.Basic()).ShouldBeOfType <Sentence>();
model.format.ShouldBe("fancy go {name}, {age}, {percentAwake}");
}
public Sentence_code_generation()
{
var model = new TestbedFixture().Compile(CellHandling.Basic());
model.IsMissing = true;
model.grammars.Each(x => x.IsMissing = true);
theCode = model.missingCode;
}
public Cell BuildCell(CellHandling handling, Fixture fixture)
{
var cell = new Cell(handling, _accessor.Name, _accessor.PropertyType);
CellModifications.Apply(cell);
return(cell);
}
public override FixtureModel Compile(CellHandling cellHandling)
{
var model = new FixtureModel(Key);
model.AddError(_error);
return(model);
}
public void format_from_attribute_if_it_exists()
{
ValueCheckMethod
.For(new Target(), x => x.Fullname(null, null))
.Compile(new Fixture(), CellHandling.Basic())
.ShouldBeOfType <Sentence>()
.format.ShouldBe("The fullname for {first} & {second} should be {expected}");
}
public void derived_format_has_the_return_value_too()
{
ValueCheckMethod
.For(new Target(), x => x.Fullname3(null, null))
.Compile(new Fixture(), CellHandling.Basic())
.ShouldBeOfType <Sentence>()
.format.ShouldBe("Fullname3({first}, {last}) should be {returnValue}");
}
public void can_correct_the_return_type_if_Task_of_T_to_T()
{
var parameter = ReflectionHelper.GetMethod <CellTarget>(x => x.GoPlacesAsync()).ReturnParameter;
var cell = Cell.For(CellHandling.Basic(), parameter, new Fixture());
cell.Type.ShouldBe(typeof(bool));
}
protected override IEnumerable <Cell> buildCells(CellHandling cellHandling, Fixture fixture)
{
_cell = new Cell(cellHandling, _key, typeof(TInput));
CellModifications.Apply(_cell);
return(new[] { _cell });
}
public GrammarModel Compile(Fixture fixture, CellHandling cells)
{
return new Sentence
{
fact = true,
format = _label,
cells = new Cell[0]
};
}
public GrammarModel Compile(Fixture fixture, CellHandling cells)
{
// Let the UI handle the format errors
_cells = buildCells(cells, fixture).ToArray();
return new Sentence
{
cells = _cells,
format = format()
};
}
public GrammarModel Compile(Fixture fixture, CellHandling cells)
{
var inner = _inner.Compile(fixture, cells);
var innerCells = inner.As<IModelWithCells>().cells;
return new Sentence
{
cells = filterCells(innerCells).ToArray(),
format = _template,
};
}
public GrammarModel Compile(Fixture fixture, CellHandling cells)
{
_cells = _comparison.BuildCells(cells, fixture);
return new SetVerification
{
title = _title,
cells = _cells,
collection = _leafName,
ordered = _ordered
};
}
public void use_a_runtime_converter_against_NULL()
{
var conversions = new Conversions();
conversions.RegisterRuntimeConversion<ColorConverter>();
var cellHandling = new CellHandling(new EquivalenceChecker(), conversions);
var cell = new Cell(cellHandling, "color", typeof (Color));
var values = new StepValues("foo");
cell.ConvertValues(new Step("foo").With("color", "NULL"), values);
values.Get("color").ShouldBeNull();
}
public void Compile(Fixture fixture, CellHandling cellHandling)
{
_cells = _method.GetParameters().Select(x => Cell.For(cellHandling, x, fixture)).ToArray();
_outputs = _cells.Where(x => x.result).ToArray();
if (_method.HasReturn())
{
ReturnCell = Cell.For(cellHandling, _method.ReturnParameter, fixture);
ReturnCell.result = true;
if (ReturnCell.Key.IsEmpty())
{
ReturnCell.Key = Format.ParseTemplateKeys().LastOrDefault() ?? "returnValue";
}
}
}
public GrammarModel Compile(Fixture fixture, CellHandling cells)
{
if (_inner is MissingGrammar)
{
return _inner.Compile(fixture, cells);
}
var innerModel = _inner.Compile(fixture, cells).As<IModelWithCells>();
return new Table
{
cells = innerModel.cells.ToArray(),
collection = _leafName,
title = Title
};
}
public void use_a_runtime_converter_with_a_value()
{
var conversions = new Conversions();
conversions.RegisterRuntimeConversion<ColorConverter>();
var cellHandling = new CellHandling(new EquivalenceChecker(), conversions);
var cell = new Cell(cellHandling, "color", typeof (Color));
var values = new StepValues("foo");
cell.ConvertValues(new Step("foo").With("color", "Red"), values);
var delayed = values.DelayedConversions.Single();
delayed.Key.ShouldBe("color");
delayed.Raw.ShouldBe("Red");
delayed.Converter.ShouldBeOfType<ColorConverter>();
}
public Cell[] BuildCells(CellHandling handling, Fixture fixture)
{
return new[]{new Cell(handling, _key, typeof(string)) };
}
public static FixtureLibrary CreateForAppDomain(CellHandling cellHandling)
{
var currentDomain = AppDomain.CurrentDomain;
var assemPath = currentDomain.BaseDirectory;
var binPath = currentDomain.SetupInformation.PrivateBinPath;
if (binPath.IsNotEmpty())
{
assemPath = assemPath.AppendPath(binPath);
}
var fixtures = AssembliesFromPath(assemPath, referencesStoryteller)
.SelectMany(FixtureTypesFor)
.Select(
type => CreateCompiledFixture(cellHandling, type));
var library = new FixtureLibrary();
fixtures.Each(x =>
{
library.Fixtures[x.Fixture.Key] = x.Fixture;
library.Models[x.Fixture.Key] = x.Model;
});
return library;
}
protected virtual IEnumerable<Cell> buildCells(CellHandling cellHandling, Fixture fixture)
{
return Enumerable.Empty<Cell>();
}
public GrammarModel Compile(Fixture fixture, CellHandling cells)
{
return Silent.Flyweight;
}
public Cell CompileCell(CellHandling cellHandling, Fixture fixture)
{
return Cell.For(cellHandling, _property, fixture);
}
GrammarModel IGrammar.Compile(Fixture fixture, CellHandling cells)
{
return this;
}
protected override IEnumerable<Cell> buildCells(CellHandling cellHandling, Fixture fixture)
{
return _properties.Select(x => x.CompileCell(cellHandling, fixture));
}
public GrammarModel Compile(Fixture fixture, CellHandling cells)
{
return new StubGrammarModel();
}
public GrammarModel Compile(Fixture fixture, CellHandling cells)
{
return _inner.Compile(fixture, cells);
}
