public void Setup()
{
_stringBuilder = new StringBuilder();
_liftWriter = new LiftWriter(_stringBuilder, false);
_dataMapper = new MemoryDataMapper <LexEntry>();
_builder = new LexEntryFromLiftBuilder(_dataMapper, null);
}
public void Setup()
{
_stringBuilder = new StringBuilder();
_liftWriter = new LiftWriter(_stringBuilder, false);
_dataMapper = new MemoryDataMapper<LexEntry>();
_builder = new LexEntryFromLiftBuilder(_dataMapper, null);
}
public void Setup()
{
_dataMapper = new MemoryDataMapper<LexEntry>();
OptionsList pretendSemanticDomainList = new OptionsList();
pretendSemanticDomainList.Options.Add(new Option("4.2.7 Play, fun", new MultiText()));
_builder = new LexEntryFromLiftBuilder(_dataMapper, pretendSemanticDomainList);
}
public LexEntryFromLiftBuilder(MemoryDataMapper <LexEntry> dataMapper, OptionsList semanticDomainsList)
{
ExpectedOptionTraits = new List <string>();
_expectedOptionCollectionTraits = new List <string>();
_dataMapper = dataMapper;
_semanticDomainsList = semanticDomainsList;
}
public LiftDataMapper(string liftFilePath, ProgressState progressState, ILiftReaderWriterProvider <T> ioProvider)
{
//set to true so that an exception in the constructor does not cause the destructor to throw
_disposed = true;
Guard.AgainstNull(progressState, "progressState");
_backend = new MemoryDataMapper <T>();
_liftFilePath = liftFilePath;
_progressState = progressState;
_ioProvider = ioProvider;
try
{
CreateEmptyLiftFileIfNeeded(liftFilePath);
MigrateLiftIfNeeded(progressState);
LoadAllLexEntries();
}
catch (Exception error)
{
// Dispose anything that we've created already.
_backend.Dispose();
throw;
}
//Now that the constructor has not thrown we can set this back to false
_disposed = false;
}
public void Setup()
{
_dataMapper = new MemoryDataMapper <LexEntry>();
OptionsList pretendSemanticDomainList = new OptionsList();
pretendSemanticDomainList.Options.Add(new Option("4.2.7 Play, fun", new MultiText()));
_builder = new LexEntryFromLiftBuilder(_dataMapper, pretendSemanticDomainList);
}
public void PassSameRepositoriesInConstructor_ThrowsArgumentException()
{
using (IDataMapper <PalasoTestItem> dataMapper = new MemoryDataMapper <PalasoTestItem>())
{
Assert.Throws <ArgumentException>(
() => new SynchronicRepository <PalasoTestItem>(dataMapper, dataMapper));
}
}
public void Setup()
{
dataMapper = new MemoryDataMapper <PalasoTestItem>();
Dictionary <string, object> results = new Dictionary <string, object>();
results["string"] = "result";
results["int"] = 12;
Token = new RecordToken <PalasoTestItem>(dataMapper, results, new TestRepositoryId(8));
}
public void Setup()
{
dataMapper = new MemoryDataMapper <PalasoTestItem>();
PopulateRepositoryWithItemsForQuerying(dataMapper);
_queryToCache = new QueryAdapter <PalasoTestItem>();
_queryToCache.ShowEach("StoredList");
_results = dataMapper.GetItemsMatching(_queryToCache);
_sortDefinitions = new SortDefinition[1];
_sortDefinitions[0] = new SortDefinition("StoredList", Comparer <string> .Default);
}
public void Setup()
{
dataMapper = new MemoryDataMapper<PalasoTestItem>();
_queryResultsA = new Dictionary<string, object>();
_queryResultsA.Add("string", "A");
_queryResultsB = new Dictionary<string, object>();
_queryResultsB.Add("string", "B");
_queryResultsEmpty = new Dictionary<string, object>();
_queryResultsEmpty.Add("string", string.Empty);
}
public void Setup()
{
dataMapper = new MemoryDataMapper <PalasoTestItem>();
_queryResultsA = new Dictionary <string, object>();
_queryResultsA.Add("string", "A");
_queryResultsB = new Dictionary <string, object>();
_queryResultsB.Add("string", "B");
_queryResultsEmpty = new Dictionary <string, object>();
_queryResultsEmpty.Add("string", string.Empty);
}
private void PopulateRepositoryWithItemsForQuerying(MemoryDataMapper <PalasoTestItem> dataMapper)
{
PalasoTestItem[] items = new PalasoTestItem[2];
items[0] = dataMapper.CreateItem();
items[0].StoredList = PopulateListWith("Item 1", "Item 3");
dataMapper.SaveItem(items[0]);
items[1] = dataMapper.CreateItem();
items[1].StoredList = PopulateListWith("Item 2", "Item 0");
dataMapper.SaveItem(items[1]);
}
public void Setup()
{
_dataMapper = new MemoryDataMapper<PalasoTestItem>();
_results = new List<RecordToken<PalasoTestItem>>();
_results.Add(new RecordToken<PalasoTestItem>(_dataMapper, new TestRepositoryId(8)));
_results.Add(new RecordToken<PalasoTestItem>(_dataMapper, new TestRepositoryId(12)));
_results.Add(new RecordToken<PalasoTestItem>(_dataMapper, new TestRepositoryId(1)));
_results.Add(new RecordToken<PalasoTestItem>(_dataMapper, new TestRepositoryId(3)));
_resultSet = new ResultSet<PalasoTestItem>(_dataMapper, _results);
}
public void Setup()
{
_dataMapper = new MemoryDataMapper <PalasoTestItem>();
_results = new List <RecordToken <PalasoTestItem> >();
_results.Add(new RecordToken <PalasoTestItem>(_dataMapper, new TestRepositoryId(8)));
_results.Add(new RecordToken <PalasoTestItem>(_dataMapper, new TestRepositoryId(12)));
_results.Add(new RecordToken <PalasoTestItem>(_dataMapper, new TestRepositoryId(1)));
_results.Add(new RecordToken <PalasoTestItem>(_dataMapper, new TestRepositoryId(3)));
_resultSet = new ResultSet <PalasoTestItem>(_dataMapper, _results);
}
private void LoadLift(string path)
{
//Performance wise, the following is not expecting a huge, 10k word list.
using (var reader = new Palaso.DictionaryServices.Lift.LiftReader(new NullProgressState(),
WeSayWordsProject.Project.GetSemanticDomainsList(),
WeSayWordsProject.Project.GetIdsOfSingleOptionFields()))
using (var m = new MemoryDataMapper <LexEntry>())
{
reader.Read(path, m);
_words.AddRange(from RepositoryId repositoryId in m.GetAllItems() select m.GetItem(repositoryId));
}
}
private void PopulateRepositoryWithItemsForQuerying(MemoryDataMapper <PalasoTestItem> dataMapper)
{
var items = new PalasoTestItem[3];
items[0] = dataMapper.CreateItem();
items[0].StoredString = "Item 3";
dataMapper.SaveItem(items[0]);
items[1] = dataMapper.CreateItem();
items[1].StoredString = "Item 0";
dataMapper.SaveItem(items[1]);
items[2] = dataMapper.CreateItem();
items[2].StoredString = "Item 2";
dataMapper.SaveItem(items[2]);
}
public void Read(string filePath, MemoryDataMapper <LexEntry> dataMapper)
{
const string status = "Loading entries";
Logger.WriteEvent(status);
_progressState.StatusLabel = status;
using (LexEntryFromLiftBuilder builder = new LexEntryFromLiftBuilder(dataMapper, _semanticDomainsList))
{
builder.AfterEntryRead += new EventHandler <LexEntryFromLiftBuilder.EntryEvent>(OnAfterEntryRead);
builder.ExpectedOptionTraits = _idsOfSingleOptionFields;
LiftParser <PalasoDataObject, LexEntry, LexSense, LexExampleSentence> parser =
new LiftParser <PalasoDataObject, LexEntry, LexSense, LexExampleSentence>(
builder);
parser.SetTotalNumberSteps += parser_SetTotalNumberSteps;
parser.SetStepsCompleted += parser_SetStepsCompleted;
parser.ParsingWarning += parser_ParsingWarning;
try
{
parser.ReadLiftFile(filePath);
if (_progressState.ExceptionThatWasEncountered != null)
{
throw _progressState.ExceptionThatWasEncountered;
}
}
// catch (LiftFormatException)
// {
// throw;
// }
catch (Exception)
{
_progressState.StatusLabel = "Looking for error in file...";
//our parser failed. Hopefully, because of bad lift. Validate it now to
//see if that's the problem.
Validator.CheckLiftWithPossibleThrow(filePath);
//if it got past that, ok, send along the error the parser encountered.
throw;
}
}
}
private void LoadLift(string path)
{
//Performance wise, the following is not expecting a huge, 10k word list.
using (var reader = new Palaso.DictionaryServices.Lift.LiftReader(new NullProgressState(),
WeSayWordsProject.Project.GetSemanticDomainsList(),
WeSayWordsProject.Project.GetIdsOfSingleOptionFields()))
using (var m = new MemoryDataMapper <LexEntry>())
{
reader.Read(path, m);
_words.AddRange(from RepositoryId repositoryId in m.GetAllItems() select m.GetItem(repositoryId));
}
foreach (var word in _words)
{
foreach (var sense in word.Senses)
{
if (_glossMeaningField)
{
// copy all definition forms to gloss then delete definition form
foreach (var form in sense.Definition.Forms)
{
//this check makes sure we don't introduce a form form a lang we allow for def, but not gloss
if (_glossWritingSystemIds.Contains(form.WritingSystemId))
{
sense.Gloss.SetAlternative(form.WritingSystemId, form.Form);
}
sense.Definition.SetAlternative(form.WritingSystemId, null);
}
}
else
{
// copy all gloss forms to definition then delete gloss form
foreach (var form in sense.Gloss.Forms)
{
//this check makes sure we don't introduce a form form a lang we allow for gloss, but not def
if (_definitionWritingSystemIds.Contains(form.WritingSystemId))
{
sense.Definition.SetAlternative(form.WritingSystemId, form.Form);
}
sense.Gloss.SetAlternative(form.WritingSystemId, null);
}
}
}
}
}
public void Setup()
{
_dataMapper = new MemoryDataMapper <PalasoTestItem>();
}
static int Main(string[] args)
{
var options = new Options();
var isValid = CommandLine.Parser.Default.ParseArgumentsStrict(args, options);
if (isValid)
{
if (options.ShowHelp)
{
Console.WriteLine(options.GetUsage());
return(0);
}
if (!File.Exists(options.InputFile))
{
Console.WriteLine("Input lift wordlist {0} does not exist", options.InputFile);
return(1);
}
if ((options.OutputFile != "Wordlist.json") && File.Exists(options.OutputFile))
{
Console.WriteLine("The file {0} already exists.", options.OutputFile);
return(1);
}
if (options.Verbose)
{
Console.WriteLine("Input file: {0}", options.InputFile);
Console.WriteLine("Output file: {0}", options.OutputFile);
}
}
else
{
// Display the default usage information
Console.WriteLine("command line parsing failed");
Console.WriteLine(options.GetUsage());
return(1);
}
List <LexEntry> _words;
_words = new List <LexEntry>();
using (ProjectDirectorySetupForTesting p = new ProjectDirectorySetupForTesting("<entry id='foo1'><lexical-unit><form lang='qaa-x-qaa'><text>fooOne</text></form></lexical-unit></entry>"))
{
WeSayWordsProject project = p.CreateLoadedProject();
using (var reader = new Palaso.DictionaryServices.Lift.LiftReader(new NullProgressState(),
WeSayWordsProject.Project.GetSemanticDomainsList(),
WeSayWordsProject.Project.GetIdsOfSingleOptionFields()))
using (var m = new MemoryDataMapper <LexEntry>())
{
reader.Read(options.InputFile, m);
_words.AddRange(from RepositoryId repositoryId in m.GetAllItems() select m.GetItem(repositoryId));
}
foreach (var word in _words)
{
foreach (var sense in word.Senses)
{
// copy all definition forms to gloss then delete definition form
foreach (var form in sense.Definition.Forms)
{
sense.Gloss.SetAlternative(form.WritingSystemId, form.Form);
sense.Definition.SetAlternative(form.WritingSystemId, null);
}
}
}
using (StreamWriter file = new StreamWriter(options.OutputFile))
{
using (JsonWriter writer = new JsonTextWriter(file))
{
writer.WriteStartArray();
foreach (LexEntry word in _words)
{
writer.WriteStartObject();
writer.WritePropertyName("lexicalid");
LanguageForm idform = word.LexicalForm.Find("en");
string lexicalid = (idform == null ? word.LexicalForm.GetFirstAlternative() : idform.Form);
writer.WriteValue(lexicalid);
foreach (var sense in word.Senses)
{
foreach (var form in sense.Gloss.Forms)
{
writer.WritePropertyName(form.WritingSystemId);
writer.WriteValue(form.Form);
}
}
writer.WriteEndObject();
}
writer.WriteEndArray();
}
}
}
return(0);
}
public override void SetUp()
{
DataMapperUnderTest = new MemoryDataMapper <PalasoTestItem>();
}
public TestEnvironment()
{
DataMapper = new MemoryDataMapper<PalasoTestItem>();
}
public void Setup()
{
dataMapper = new MemoryDataMapper <PalasoTestItem>();
Token = new RecordToken <PalasoTestItem>(dataMapper, new TestRepositoryId(8));
}
public TestEnvironment()
{
DataMapper = new MemoryDataMapper <PalasoTestItem>();
}
