/// <summary>
/// Fires the BioPatML Repository Web service to grab our desire BioPatML pattern.
/// </summary>
/// <param name="id"></param>
/// <param name="type"></param>
public void GetWebPatternDetail(String id, String type)
{
#region Code for the blue "Loading" visual effect
txtLoading.Visibility = System.Windows.Visibility.Visible;
BlinkLoading.RepeatBehavior = RepeatBehavior.Forever;
BlinkLoading.Begin();
DefinitionInfo definition = new DefinitionInfo()
{
MainPatternId = id,
MainPatternType = type
};
#endregion Code for the blue "Loading" visual effect
#region Code for the background worker to invoke our BioPatML repository service
bw.DoWork += delegate(object s, DoWorkEventArgs args)
{
#region Initialize all the essential variables
DefinitionInfo target = (DefinitionInfo)args.Argument;
bool done = false;
string result = string.Empty;
BioPatMLDataRepo.BioPatMLDataServiceClient repository = new BioPatMLDataServiceClient();
#endregion
repository.GetPatternDetailInfoCompleted += delegate
(object sender, GetPatternDetailInfoCompletedEventArgs e)
{
//When finish retrieving data we assign the BioPatML String to the result variable
result = e.Result.ToString();
done = true;
};
//Fires the web service and pass in a definition which contains the pattern Id and its type
repository.GetPatternDetailInfoAsync(target);
while (!done) { System.Threading.Thread.Sleep(2000); };
repository.CloseAsync(); //close the service
repository = null; //clean up resources
args.Result = result;
};
#endregion #region Code for the background worker to invoke our BioPatML repository service
//When worker has finished its job
//we want him to remake our repository treeview n end all visual effects
bw.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args)
{
ReconstructTreeView(currBioPatMLStr = args.Result.ToString());
#region End the blinking loading effect
txtLoading.Visibility = System.Windows.Visibility.Collapsed;
BlinkLoading.Stop();
#endregion
};
bw.RunWorkerAsync(definition);
}
private void HandleMappingWithAllLooseProperties(
DefinitionInfo mappingDefinition,
DefinitionInfo keyDefinition,
DefinitionInfo valueDefinition,
MappingToken mapping)
{
var keys = new HashSet <String>(StringComparer.OrdinalIgnoreCase);
while (m_unraveler.AllowScalar(mappingDefinition.Expand, out ScalarToken nextKeyScalar))
{
// Expression
if (nextKeyScalar is ExpressionToken)
{
if (nextKeyScalar is BasicExpressionToken)
{
mapping.Add(nextKeyScalar, Evaluate(valueDefinition));
}
else
{
var anyDefinition = new DefinitionInfo(mappingDefinition, TemplateConstants.Any);
mapping.Add(nextKeyScalar, Evaluate(anyDefinition));
}
continue;
}
// Not a string
if (!(nextKeyScalar is StringToken nextKey))
{
nextKey = new StringToken(nextKeyScalar.FileId, nextKeyScalar.Line, nextKeyScalar.Column, nextKeyScalar.ToString());
}
// Duplicate
if (!keys.Add(nextKey.Value))
{
m_context.Error(nextKey, TemplateStrings.ValueAlreadyDefined(nextKey.Value));
m_unraveler.SkipMappingValue();
continue;
}
// Validate
Validate(nextKey, keyDefinition);
// Add the pair
var nextValue = Evaluate(valueDefinition);
mapping.Add(nextKey, nextValue);
}
m_unraveler.ReadMappingEnd();
}
private void Validate(
ref ScalarToken scalar,
DefinitionInfo definition)
{
switch (scalar.Type)
{
case TokenType.Null:
case TokenType.Boolean:
case TokenType.Number:
case TokenType.String:
var literal = scalar as LiteralToken;
// Legal
if (definition.Get <ScalarDefinition>().Any(x => x.IsMatch(literal)))
{
return;
}
// Not a string, convert
if (literal.Type != TokenType.String)
{
literal = new StringToken(literal.FileId, literal.Line, literal.Column, literal.ToString());
// Legal
if (definition.Get <StringDefinition>().Any(x => x.IsMatch(literal)))
{
scalar = literal;
return;
}
}
// Illegal
m_context.Error(literal, TemplateStrings.UnexpectedValue(literal));
break;
case TokenType.BasicExpression:
// Illegal
if (definition.AllowedContext.Length == 0)
{
m_context.Error(scalar, TemplateStrings.ExpressionNotAllowed());
}
break;
default:
m_context.Error(scalar, TemplateStrings.UnexpectedValue(scalar));
break;
}
}
public void Should_be_stored_a_created_definition_hash()
{
// Arrange
var sampleInfo = new DefinitionInfo()
{
Id = "def01", Text = "def01_text"
};
var factory = new DefinitionDocumentFactory(localDataProvider);
// Act
var result = factory.CreateDefinitionDocumentFromInfo(localDataProvider.GetSession(), sampleInfo);
// Assert
Assert.IsFalse(string.IsNullOrEmpty(result.Hash));
}
static void GoToDefinition(DefinitionInfo definition)
{
if (!definition.HasFileName())
{
return;
}
var provider = FileService.OpenFile(definition.fileName) as ITextEditorProvider;
if (provider != null)
{
Location location = provider.TextEditor.Document.OffsetToPosition(definition.minChar);
FileService.JumpToFilePosition(definition.fileName, location.Line, location.Column);
}
}
private Package CreatePackage(Request request, DefinitionInfo definitionInfo, DateTime?fakeDate = null)
{
var date = fakeDate ?? DateTime.Now;
var fakePackage = new Package()
{
Date = date,
Definitions = new DefinitionInfo[] { definitionInfo },
CollectRequests = new Request[] { request },
ScheduleInformation = new ScheduleInformation()
{
ScheduleDate = date
}
};
return(fakePackage);
}
public void Should_be_possible_to_create_a_definition_document_from_Dto()
{
// Arrange
var sampleInfo = new DefinitionInfo();
sampleInfo.Id = "def01";
sampleInfo.Text = "def01_text";
var factory = new DefinitionDocumentFactory(localDataProvider);
// Act
var definitionDocument = factory.CreateDefinitionDocumentFromInfo(localDataProvider.GetSession(), sampleInfo);
// Assert
Assert.IsNotNull(definitionDocument);
Assert.AreEqual(sampleInfo.Id, definitionDocument.OriginalId);
Assert.AreEqual(sampleInfo.Text, definitionDocument.Text);
}
public DefinitionInfo(
DefinitionInfo parent,
String name)
{
m_schema = parent.m_schema;
// Lookup the definition
Definition = m_schema.GetDefinition(name);
// Record allowed context
if (Definition.ReaderContext.Length > 0)
{
AllowedContext = new HashSet <String>(parent.AllowedContext.Concat(Definition.ReaderContext), StringComparer.OrdinalIgnoreCase).ToArray();
}
else
{
AllowedContext = parent.AllowedContext;
}
}
public DefinitionInfo(
DefinitionInfo parent,
String name)
{
m_schema = parent.m_schema;
// Lookup the definition
Definition = m_schema.GetDefinition(name);
// Determine whether to expand
if (Definition.Context.Length > 0)
{
AllowedContext = new HashSet <String>(parent.AllowedContext.Concat(Definition.Context)).ToArray();
}
else
{
AllowedContext = parent.AllowedContext;
}
}
public void Should_be_possible_to_load_a_created_definition()
{
IDocumentSession fakeSession = localDataProvider.GetSession();
// Arrange
var sampleInfo = new DefinitionInfo();
sampleInfo.Id = "def01";
sampleInfo.Text = "def01_text";
var factory = new DefinitionDocumentFactory(localDataProvider);
// Act
factory.CreateDefinitionDocumentFromInfo(fakeSession, sampleInfo);
var definitionDocument = localDataProvider.GetSession().Query <DefinitionDocument>().Single(x => x.OriginalId == sampleInfo.Id);
// Assert
Assert.IsNotNull(definitionDocument);
Assert.AreEqual(sampleInfo.Id, definitionDocument.OriginalId);
Assert.AreEqual(sampleInfo.Text, definitionDocument.Text);
}
public TypeScriptLanguageItemWindow(TextEditor ed, Gdk.ModifierType modifierState, DefinitionInfo result)
{
string tooltip = GetTooltopString (result);
if (string.IsNullOrEmpty (tooltip)|| tooltip == "?") {
IsEmpty = true;
return;
}
var label = new MonoDevelop.Components.FixedWidthWrapLabel () {
Wrap = Pango.WrapMode.WordChar,
Indent = -20,
BreakOnCamelCasing = true,
BreakOnPunctuation = true,
Markup = tooltip,
};
this.BorderWidth = 3;
Add (label);
UpdateFont (label);
EnableTransparencyControl = true;
}
static void GoToDefinition(DefinitionInfo definition)
{
if (!definition.HasFileName())
{
return;
}
IViewContent view = FileService.OpenFile(definition.fileName);
if (view == null)
{
return;
}
ITextEditor textEditor = view.GetService <ITextEditor>();
if (textEditor != null)
{
TextLocation location = textEditor.Document.GetLocation(definition.minChar);
FileService.JumpToFilePosition(definition.fileName, location.Line, location.Column);
}
}
public DefinitionInfo(
DefinitionInfo parent,
String name)
{
m_schema = parent.m_schema;
m_availableContext = parent.m_availableContext;
// Lookup the definition
Definition = m_schema.GetDefinition(name);
// Determine whether to expand
if (Definition.Context.Length > 0)
{
m_allowedContext = new HashSet <String>(parent.m_allowedContext.Concat(Definition.Context)).ToArray();
Expand = m_availableContext.IsSupersetOf(m_allowedContext);
}
else
{
m_allowedContext = parent.m_allowedContext;
Expand = parent.Expand;
}
}
private void HandleMappingWithWellKnownProperties(
DefinitionInfo definition,
List <MappingDefinition> mappingDefinitions,
MappingToken mapping)
{
// Check if loose properties are allowed
String looseKeyType = null;
String looseValueType = null;
DefinitionInfo?looseKeyDefinition = null;
DefinitionInfo?looseValueDefinition = null;
if (!String.IsNullOrEmpty(mappingDefinitions[0].LooseKeyType))
{
looseKeyType = mappingDefinitions[0].LooseKeyType;
looseValueType = mappingDefinitions[0].LooseValueType;
}
var keys = new HashSet <String>(StringComparer.OrdinalIgnoreCase);
while (m_unraveler.AllowScalar(definition.Expand, out ScalarToken nextKeyScalar))
{
// Expression
if (nextKeyScalar is ExpressionToken)
{
var anyDefinition = new DefinitionInfo(definition, TemplateConstants.Any);
mapping.Add(nextKeyScalar, Evaluate(anyDefinition));
continue;
}
// Not a string, convert
if (!(nextKeyScalar is StringToken nextKey))
{
nextKey = new StringToken(nextKeyScalar.FileId, nextKeyScalar.Line, nextKeyScalar.Column, nextKeyScalar.ToString());
}
// Duplicate
if (!keys.Add(nextKey.Value))
{
m_context.Error(nextKey, TemplateStrings.ValueAlreadyDefined(nextKey.Value));
m_unraveler.SkipMappingValue();
continue;
}
// Well known
if (m_schema.TryMatchKey(mappingDefinitions, nextKey.Value, out String nextValueType))
{
var nextValueDefinition = new DefinitionInfo(definition, nextValueType);
var nextValue = Evaluate(nextValueDefinition);
mapping.Add(nextKey, nextValue);
continue;
}
// Loose
if (looseKeyType != null)
{
if (looseKeyDefinition == null)
{
looseKeyDefinition = new DefinitionInfo(definition, looseKeyType);
looseValueDefinition = new DefinitionInfo(definition, looseValueType);
}
Validate(nextKey, looseKeyDefinition.Value);
var nextValue = Evaluate(looseValueDefinition.Value);
mapping.Add(nextKey, nextValue);
continue;
}
// Error
m_context.Error(nextKey, TemplateStrings.UnexpectedValue(nextKey.Value));
m_unraveler.SkipMappingValue();
}
// Only one
if (mappingDefinitions.Count > 1)
{
var hitCount = new Dictionary <String, Int32>();
foreach (MappingDefinition mapdef in mappingDefinitions)
{
foreach (String key in mapdef.Properties.Keys)
{
if (!hitCount.TryGetValue(key, out Int32 value))
{
hitCount.Add(key, 1);
}
else
{
hitCount[key] = value + 1;
}
}
}
List <String> nonDuplicates = new List <String>();
foreach (String key in hitCount.Keys)
{
if (hitCount[key] == 1)
{
nonDuplicates.Add(key);
}
}
nonDuplicates.Sort();
String listToDeDuplicate = String.Join(", ", nonDuplicates);
m_context.Error(mapping, TemplateStrings.UnableToDetermineOneOf(listToDeDuplicate));
}
m_unraveler.ReadMappingEnd();
}
internal static TemplateToken Evaluate(
TemplateContext context,
String type,
TemplateToken template,
Int32 removeBytes,
Int32?fileId,
Boolean omitHeader = false)
{
TemplateToken result;
if (!omitHeader)
{
if (fileId != null)
{
context.TraceWriter.Info("{0}", $"Begin evaluating template '{context.GetFileName(fileId.Value)}'");
}
else
{
context.TraceWriter.Info("{0}", "Begin evaluating template");
}
}
var evaluator = new TemplateEvaluator(context, template, removeBytes);
try
{
var availableContext = new HashSet <String>(StringComparer.OrdinalIgnoreCase);
foreach (var key in context.ExpressionValues.Keys)
{
availableContext.Add(key);
}
foreach (var function in context.ExpressionFunctions)
{
availableContext.Add($"{function.Name}()");
}
var definitionInfo = new DefinitionInfo(context.Schema, type, availableContext);
result = evaluator.Evaluate(definitionInfo);
if (result != null)
{
evaluator.m_unraveler.ReadEnd();
}
}
catch (Exception ex)
{
context.Error(fileId, null, null, ex);
result = null;
}
if (!omitHeader)
{
if (fileId != null)
{
context.TraceWriter.Info("{0}", $"Finished evaluating template '{context.GetFileName(fileId.Value)}'");
}
else
{
context.TraceWriter.Info("{0}", "Finished evaluating template");
}
}
return(result);
}
public void SetRootDefinitions(DefinitionInfo[] definitions)
{
this.m_RootDefinitions = definitions;
}
string GetTooltopString(DefinitionInfo info)
{
return string.Format ("{0} {1} (in {2} {3})",
info.Kind,
info.Name,
info.ContainerKind,
info.ContainerName);
}
private TemplateToken ReadValue(DefinitionInfo definition)
{
m_memory.IncrementEvents();
// Scalar
if (m_objectReader.AllowLiteral(out LiteralToken literal))
{
var scalar = ParseScalar(literal, definition.AllowedContext);
Validate(ref scalar, definition);
m_memory.AddBytes(scalar);
return(scalar);
}
// Sequence
if (m_objectReader.AllowSequenceStart(out SequenceToken sequence))
{
m_memory.IncrementDepth();
m_memory.AddBytes(sequence);
var sequenceDefinition = definition.Get <SequenceDefinition>().FirstOrDefault();
// Legal
if (sequenceDefinition != null)
{
var itemDefinition = new DefinitionInfo(definition, sequenceDefinition.ItemType);
// Add each item
while (!m_objectReader.AllowSequenceEnd())
{
var item = ReadValue(itemDefinition);
sequence.Add(item);
}
}
// Illegal
else
{
// Error
m_context.Error(sequence, TemplateStrings.UnexpectedSequenceStart());
// Skip each item
while (!m_objectReader.AllowSequenceEnd())
{
SkipValue();
}
}
m_memory.DecrementDepth();
return(sequence);
}
// Mapping
if (m_objectReader.AllowMappingStart(out MappingToken mapping))
{
m_memory.IncrementDepth();
m_memory.AddBytes(mapping);
var mappingDefinitions = definition.Get <MappingDefinition>().ToList();
// Legal
if (mappingDefinitions.Count > 0)
{
if (mappingDefinitions.Count > 1 ||
m_schema.HasProperties(mappingDefinitions[0]) ||
String.IsNullOrEmpty(mappingDefinitions[0].LooseKeyType))
{
HandleMappingWithWellKnownProperties(definition, mappingDefinitions, mapping);
}
else
{
var keyDefinition = new DefinitionInfo(definition, mappingDefinitions[0].LooseKeyType);
var valueDefinition = new DefinitionInfo(definition, mappingDefinitions[0].LooseValueType);
HandleMappingWithAllLooseProperties(definition, keyDefinition, valueDefinition, mapping);
}
}
// Illegal
else
{
m_context.Error(mapping, TemplateStrings.UnexpectedMappingStart());
while (!m_objectReader.AllowMappingEnd())
{
SkipValue();
SkipValue();
}
}
m_memory.DecrementDepth();
return(mapping);
}
throw new InvalidOperationException(TemplateStrings.ExpectedScalarSequenceOrMapping());
}
public String GetPatternDetailInfo(DefinitionInfo def)
{
return RepositoryManager.GetPatternXML(def);
}
public DefinitionDocument CreateDefinitionDocumentFromInfo(IDocumentSession session, DefinitionInfo definitionInfo)
{
var definition = new DefinitionDocument();
// Save properties
definition.OriginalId = definitionInfo.Id;
definition.Text = definitionInfo.Text;
// Generate document hash
definition.Hash = Convert.ToBase64String(new System.Security.Cryptography.SHA256Managed().ComputeHash(Encoding.UTF8.GetBytes(definition.Text)));
session.Store(definition);
session.SaveChanges();
return(definition);
}
private TemplateToken Evaluate(DefinitionInfo definition)
{
// Scalar
if (m_unraveler.AllowScalar(definition.Expand, out ScalarToken scalar))
{
if (scalar is LiteralToken literal)
{
Validate(ref literal, definition);
return(literal);
}
else
{
return(scalar);
}
}
// Sequence start
if (m_unraveler.AllowSequenceStart(definition.Expand, out SequenceToken sequence))
{
var sequenceDefinition = definition.Get <SequenceDefinition>().FirstOrDefault();
// Legal
if (sequenceDefinition != null)
{
var itemDefinition = new DefinitionInfo(definition, sequenceDefinition.ItemType);
// Add each item
while (!m_unraveler.AllowSequenceEnd(definition.Expand))
{
var item = Evaluate(itemDefinition);
sequence.Add(item);
}
}
// Illegal
else
{
// Error
m_context.Error(sequence, TemplateStrings.UnexpectedSequenceStart());
// Skip each item
while (!m_unraveler.AllowSequenceEnd(expand: false))
{
m_unraveler.SkipSequenceItem();
}
}
return(sequence);
}
// Mapping
if (m_unraveler.AllowMappingStart(definition.Expand, out MappingToken mapping))
{
var mappingDefinitions = definition.Get <MappingDefinition>().ToList();
// Legal
if (mappingDefinitions.Count > 0)
{
if (mappingDefinitions.Count > 1 ||
m_schema.HasProperties(mappingDefinitions[0]) ||
String.IsNullOrEmpty(mappingDefinitions[0].LooseKeyType))
{
HandleMappingWithWellKnownProperties(definition, mappingDefinitions, mapping);
}
else
{
var keyDefinition = new DefinitionInfo(definition, mappingDefinitions[0].LooseKeyType);
var valueDefinition = new DefinitionInfo(definition, mappingDefinitions[0].LooseValueType);
HandleMappingWithAllLooseProperties(definition, keyDefinition, valueDefinition, mapping);
}
}
// Illegal
else
{
m_context.Error(mapping, TemplateStrings.UnexpectedMappingStart());
while (!m_unraveler.AllowMappingEnd(expand: false))
{
m_unraveler.SkipMappingKey();
m_unraveler.SkipMappingValue();
}
}
return(mapping);
}
throw new ArgumentException(TemplateStrings.ExpectedScalarSequenceOrMapping());
}
private void HandleMappingWithWellKnownProperties(
DefinitionInfo definition,
List <MappingDefinition> mappingDefinitions,
MappingToken mapping)
{
// Check if loose properties are allowed
String looseKeyType = null;
String looseValueType = null;
DefinitionInfo?looseKeyDefinition = null;
DefinitionInfo?looseValueDefinition = null;
if (!String.IsNullOrEmpty(mappingDefinitions[0].LooseKeyType))
{
looseKeyType = mappingDefinitions[0].LooseKeyType;
looseValueType = mappingDefinitions[0].LooseValueType;
}
var keys = new HashSet <String>(StringComparer.OrdinalIgnoreCase);
var hasExpressionKey = false;
while (m_objectReader.AllowLiteral(out LiteralToken rawLiteral))
{
var nextKeyScalar = ParseScalar(rawLiteral, definition.AllowedContext);
// Expression
if (nextKeyScalar is ExpressionToken)
{
hasExpressionKey = true;
// Legal
if (definition.AllowedContext.Length > 0)
{
m_memory.AddBytes(nextKeyScalar);
var anyDefinition = new DefinitionInfo(definition, TemplateConstants.Any);
mapping.Add(nextKeyScalar, ReadValue(anyDefinition));
}
// Illegal
else
{
m_context.Error(nextKeyScalar, TemplateStrings.ExpressionNotAllowed());
SkipValue();
}
continue;
}
// Not a string, convert
if (!(nextKeyScalar is StringToken nextKey))
{
nextKey = new StringToken(nextKeyScalar.FileId, nextKeyScalar.Line, nextKeyScalar.Column, nextKeyScalar.ToString());
}
// Duplicate
if (!keys.Add(nextKey.Value))
{
m_context.Error(nextKey, TemplateStrings.ValueAlreadyDefined(nextKey.Value));
SkipValue();
continue;
}
// Well known
if (m_schema.TryMatchKey(mappingDefinitions, nextKey.Value, out String nextValueType))
{
m_memory.AddBytes(nextKey);
var nextValueDefinition = new DefinitionInfo(definition, nextValueType);
var nextValue = ReadValue(nextValueDefinition);
mapping.Add(nextKey, nextValue);
continue;
}
// Loose
if (looseKeyType != null)
{
if (looseKeyDefinition == null)
{
looseKeyDefinition = new DefinitionInfo(definition, looseKeyType);
looseValueDefinition = new DefinitionInfo(definition, looseValueType);
}
Validate(nextKey, looseKeyDefinition.Value);
m_memory.AddBytes(nextKey);
var nextValue = ReadValue(looseValueDefinition.Value);
mapping.Add(nextKey, nextValue);
continue;
}
// Error
m_context.Error(nextKey, TemplateStrings.UnexpectedValue(nextKey.Value));
SkipValue();
}
// Only one
if (mappingDefinitions.Count > 1)
{
var hitCount = new Dictionary <String, Int32>();
foreach (MappingDefinition mapdef in mappingDefinitions)
{
foreach (String key in mapdef.Properties.Keys)
{
if (!hitCount.TryGetValue(key, out Int32 value))
{
hitCount.Add(key, 1);
}
else
{
hitCount[key] = value + 1;
}
}
}
List <String> nonDuplicates = new List <String>();
foreach (String key in hitCount.Keys)
{
if (hitCount[key] == 1)
{
nonDuplicates.Add(key);
}
}
nonDuplicates.Sort();
String listToDeDuplicate = String.Join(", ", nonDuplicates);
m_context.Error(mapping, TemplateStrings.UnableToDetermineOneOf(listToDeDuplicate));
}
else if (mappingDefinitions.Count == 1 && !hasExpressionKey)
{
foreach (var property in mappingDefinitions[0].Properties)
{
if (property.Value.Required)
{
if (!keys.Contains(property.Key))
{
m_context.Error(mapping, $"Required property is missing: {property.Key}");
}
}
}
}
ExpectMappingEnd();
}