public static AttributeList FromXliffMetadata(MetadataContainer metadata)
{
if (metadata != null && metadata.HasGroups)
{
MetaGroup defaultGroup = null;
foreach (var group in metadata.Groups)
{
if (group.Id == "XliffLib")
{
defaultGroup = group;
break;
}
}
if (defaultGroup != null)
{
var attributes = new AttributeList();
foreach (Meta item in defaultGroup.Containers.OfType <Meta>())
{
attributes.Add(item.Type, item.NonTranslatableText);
}
return(attributes);
}
}
return(null);
}
public void MetadataDefaultValue_MetaGroup()
{
MetaGroup group;
group = new MetaGroup();
Assert.IsNull(group.AppliesTo, "AppliesTo is incorrect.");
Assert.IsNull(group.Category, "Category is incorrect.");
Assert.AreEqual(0, group.Containers.Count, "Containers count is incorrect.");
Assert.IsNull(group.Id, "Id is incorrect.");
}
public XliffDocument ExecuteMerge(XliffDocument document)
{
var groups = document.CollapseChildren <Group>().Where(g => g.Id.StartsWith("u") && g.Id.Split('-').Length == 2);
foreach (var group in groups)
{
var unitId = group.Id.Replace("-g", "");
var newUnit = new Unit(unitId);
newUnit.Name = group.Name;
if (group.Metadata != null)
{
var newMetadataContainer = new MetadataContainer();
foreach (var metaGroup in group.Metadata.Groups)
{
var newMetaGroup = new MetaGroup();
newMetaGroup.Id = metaGroup.Id;
foreach (Meta item in metaGroup.Containers)
{
var newElement = new Meta(item.Type, item.NonTranslatableText);
newMetaGroup.Containers.Add(newElement);
}
newMetadataContainer.Groups.Add(newMetaGroup);
}
newUnit.Metadata = newMetadataContainer;
}
var newSegment = new Segment();
newSegment.Source = SetSourceValue(group);
newSegment.Target = SetTargetValue(group);
newUnit.Resources.Add(newSegment);
var parentFile = group.Parent as File;
if (parentFile != null)
{
parentFile.Containers.Add(newUnit);
parentFile.Containers.Remove(group);
}
else
{
var parentGroup = group.Parent as Group;
if (parentGroup != null)
{
parentGroup.Containers.Add(newUnit);
parentGroup.Containers.Remove(group);
}
}
}
return(document);
}
public MetadataContainer ToXliffMetadata()
{
var metadata = new MetadataContainer();
var defaultGroup = new MetaGroup()
{
Id = "XliffLib"
};
foreach (var attribute in this)
{
var metadataItem = new Meta(attribute.Key, attribute.Value);
defaultGroup.Containers.Add((metadataItem));
}
metadata.Groups.Add(defaultGroup);
return(metadata);
}
public void MetaGroup(XlfEventArgs args)
{
if (args.IsEndElement)
{
stack.Pop();
}
else
{
object parent = stack.Peek();
switch (parent)
{
case Metadata m:
MetaGroup mg = mapper.Map <MetaGroup>(args);
m.Groups.Add(mg);
stack.Push(mg);
break;
}
}
}
/// <summary>
/// Demonstrates how to store metadata in a <see cref="File"/> element.
/// </summary>
public static void StoreMetadata()
{
File file;
Meta meta;
MetaGroup metaGroup;
file = new File("id");
file.Metadata = new MetadataContainer();
metaGroup = new MetaGroup();
metaGroup.AppliesTo = MetaGroupSubject.Source;
metaGroup.Category = "document_state";
metaGroup.Id = "g1";
file.Metadata.Groups.Add(metaGroup);
meta = new Meta("draft");
meta.Type = "phase";
metaGroup.Containers.Add(meta);
}
public void XliffWriter_Metadata()
{
MetaGroup group;
Unit unit;
string actualValue;
group = new MetaGroup();
group.AppliesTo = MetaGroupSubject.Source;
group.Category = "category";
group.Containers.Add(new Meta("type", "text"));
unit = new Unit("u1");
unit.Metadata = new MetadataContainer();
unit.Metadata.Groups.Add(group);
this._document.Files.Add(new File("f1"));
this._document.Files[0].Containers.Add(unit);
actualValue = this.Serialize();
Assert.AreEqual(TestUtilities.GetFileContents(TestData.UnitWithMetadata), actualValue);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
JsonSerializer serializer)
{
var jobject = JObject.Load(reader);
object resolvedType = null;
var h = jobject["meta"];
if (h != null)
{
resolvedType = new MetaGroup();
}
else
{
resolvedType = new Metaitem();
}
serializer.Populate(jobject.CreateReader(), resolvedType);
return(resolvedType);
}
public void TestInitialize()
{
this._element = new MetaGroup();
this._provider = this._element;
}
private TranslationContainer SplitUnit(Unit unit, string text, bool isCData = true)
{
string[] paragraphs;
if (isCData)
{
paragraphs = text.SplitByDefaultTags();
}
else
{
paragraphs = text.SplitPlainText();
}
if (paragraphs.Count() == 0)
{
return(unit);
}
else if (!isCData && paragraphs.Count() == 1)
{
return(unit);
}
else
{
var newGroup = new Group(unit.Id + "-g");
newGroup.Name = unit.Name;
if (unit.Metadata != null)
{
var newMetadataContainer = new MetadataContainer();
foreach (var metaGroup in unit.Metadata.Groups)
{
var newMetaGroup = new MetaGroup();
newMetaGroup.Id = metaGroup.Id;
foreach (Meta item in metaGroup.Containers)
{
var newElement = new Meta(item.Type, item.NonTranslatableText);
newMetaGroup.Containers.Add(newElement);
}
newMetadataContainer.Groups.Add(newMetaGroup);
}
newGroup.Metadata = newMetadataContainer;
}
var i = 0;
foreach (var para in paragraphs)
{
i++;
var paraUnit = new Unit(unit.Id + "-" + i);
var newSegment = new Segment();
var source = new Source();
ResourceStringContent content;
if (isCData)
{
string containingTag = para.GetContainingTag();
string newContent = para.RemoveContainingTag();
paraUnit.Name = containingTag;
if (newContent.IsHtml())
{
content = new CDataTag(newContent);
}
else
{
content = new PlainText(newContent);
}
}
else
{
content = new PlainText(para);
}
source.Text.Add(content);
newSegment.Source = source;
paraUnit.Resources.Add(newSegment);
newGroup.Containers.Add(paraUnit);
}
var parentFile = unit.Parent as File;
if (parentFile != null)
{
var index = parentFile.Containers.IndexOf(unit);
parentFile.Containers[index] = newGroup;
}
else
{
var parentGroup = unit.Parent as Group;
if (parentGroup != null)
{
var index = parentGroup.Containers.IndexOf(unit);
parentGroup.Containers[index] = newGroup;
}
}
return(newGroup);
}
}
public XliffDocument ExecuteExtraction(XliffDocument document)
{
var units = document.CollapseChildren <Unit>();
foreach (var unit in units)
{
var originalData = new OriginalData();
var subflows = new Dictionary <string, string>();
foreach (var resource in unit.Resources)
{
var segment = resource as Segment;
if (segment != null)
{
var cdata = segment.Source.Text[0] as CDataTag;
if (cdata == null)
{
continue;
}
var html = cdata.Text;
var inlineCodeExtraction = html.ConvertHtmlTagsInInLineCodes(unit.Id + "-");
foreach (var data in inlineCodeExtraction.OriginalData)
{
originalData.AddData(data.Value, data.Key);
}
segment.Source.Text.Clear();
segment.Source.Text.AddAll(inlineCodeExtraction.Text);
if (inlineCodeExtraction.SubFlow.Count > 0)
{
subflows = inlineCodeExtraction.SubFlow;
}
}
}
if (originalData.HasData)
{
unit.OriginalData = originalData;
}
if (subflows.Count > 0)
{
var newGroup = new Group(unit.Id + "-g");
newGroup.Type = unit.Type;
newGroup.Name = unit.Name;
unit.Type = null;
if (unit.Metadata != null)
{
var newMetadataContainer = new MetadataContainer();
foreach (var metaGroup in unit.Metadata.Groups)
{
var newMetaGroup = new MetaGroup();
newMetaGroup.Id = metaGroup.Id;
foreach (Meta item in metaGroup.Containers)
{
var newElement = new Meta(item.Type, item.NonTranslatableText);
newMetaGroup.Containers.Add(newElement);
}
newMetadataContainer.Groups.Add(newMetaGroup);
}
newGroup.Metadata = newMetadataContainer;
unit.Metadata = null;
}
foreach (var subflowItem in subflows)
{
var subFlowUnit = new Unit(subflowItem.Key);
var newSegment = new Segment();
var source = new Source();
var content = new PlainText(subflowItem.Value);
source.Text.Add(content);
newSegment.Source = source;
subFlowUnit.Resources.Add(newSegment);
newGroup.Containers.Add(subFlowUnit);
}
var parentFile = unit.Parent as File;
if (parentFile != null)
{
var index = parentFile.Containers.IndexOf(unit);
parentFile.Containers[index] = newGroup;
}
else
{
var parentGroup = unit.Parent as Group;
if (parentGroup != null)
{
var index = parentGroup.Containers.IndexOf(unit);
parentGroup.Containers[index] = newGroup;
}
}
newGroup.Containers.Add(unit);
}
}
return(document);
}
public void TestInitialize()
{
this._element = new MetaGroup();
this._provider = this._element;
}
bool IEveRepository.TryGetMetaGroupById(MetaGroupId id, out MetaGroup value)
{
throw new NotImplementedException();
}
private TranslationContainer SplitUnit(Unit unit, string text, bool isCData = true)
{
SimplifiedHtmlContentItem[] paragraphs;
if (isCData)
{
paragraphs = _htmlParser.SplitHtml(text);
}
else
{
paragraphs = _htmlParser.SplitPlainText(text);
}
if (paragraphs.Count() == 0)
{
return(unit);
}
else if (!isCData && paragraphs.Count() == 1)
{
return(unit);
}
else
{
var newGroup = new Group(unit.Id + "-g");
newGroup.Type = unit.Type;
newGroup.Name = unit.Name;
if (unit.Metadata != null)
{
var newMetadataContainer = new MetadataContainer();
foreach (var metaGroup in unit.Metadata.Groups)
{
var newMetaGroup = new MetaGroup();
newMetaGroup.Id = metaGroup.Id;
foreach (Meta item in metaGroup.Containers)
{
var newElement = new Meta(item.Type, item.NonTranslatableText);
newMetaGroup.Containers.Add(newElement);
}
newMetadataContainer.Groups.Add(newMetaGroup);
}
newGroup.Metadata = newMetadataContainer;
}
var i = 0;
foreach (var para in paragraphs)
{
i++;
var paraUnit = new Unit(unit.Id + "-" + i);
var newSegment = new Segment();
if (para.Attributes.Count() > 0)
{
var newMetadataContainer = new MetadataContainer();
var attributeMetaGroup = new MetaGroup();
attributeMetaGroup.Id = ORIGINALATTRIBUTES;
foreach (var attribute in para.Attributes)
{
var newElement = new Meta(attribute.Key, attribute.Value);
attributeMetaGroup.Containers.Add(newElement);
}
newMetadataContainer.Groups.Add(attributeMetaGroup);
paraUnit.Metadata = newMetadataContainer;
}
var source = new Source();
ResourceStringContent content;
if (isCData)
{
string containingTag = para.Name;
string newContent = para.InnerContent();
if (!string.IsNullOrWhiteSpace(containingTag))
{
paraUnit.Type = _htmlParser.ToXliffHtmlType(containingTag);
}
if (newContent.IsHtml())
{
content = new CDataTag(newContent);
}
else
{
content = new PlainText(newContent);
}
}
else
{
content = new PlainText(para.Content);
}
source.Text.Add(content);
newSegment.Source = source;
paraUnit.Resources.Add(newSegment);
newGroup.Containers.Add(paraUnit);
}
var parentFile = unit.Parent as File;
if (parentFile != null)
{
var index = parentFile.Containers.IndexOf(unit);
parentFile.Containers[index] = newGroup;
}
else
{
var parentGroup = unit.Parent as Group;
if (parentGroup != null)
{
var index = parentGroup.Containers.IndexOf(unit);
parentGroup.Containers[index] = newGroup;
}
}
return(newGroup);
}
}
public XliffDocument ExecuteExtraction(XliffDocument document)
{
var units = document.CollapseChildren <Unit>();
foreach (var unit in units)
{
foreach (var resource in unit.Resources)
{
var segment = resource as Segment;
if (segment != null)
{
var cdata = segment.Source.Text[0] as CDataTag;
if (cdata == null)
{
continue;
}
var html = cdata.Text;
var paragraphs = html.SplitByParagraphs();
if (paragraphs.Count() > 1)
{
//TODO: Copy name and other attributes
var newGroup = new Group(unit.Id + "-g");
newGroup.Name = unit.Name;
if (unit.Metadata != null)
{
var newMetadataContainer = new MetadataContainer();
foreach (var metaGroup in unit.Metadata.Groups)
{
var newMetaGroup = new MetaGroup();
newMetaGroup.Id = metaGroup.Id;
foreach (Meta item in metaGroup.Containers)
{
var newElement = new Meta(item.Type, item.NonTranslatableText);
newMetaGroup.Containers.Add(newElement);
}
newMetadataContainer.Groups.Add(newMetaGroup);
}
newGroup.Metadata = newMetadataContainer;
}
var i = 0;
foreach (var para in paragraphs)
{
i++;
var paraUnit = new Unit(unit.Id + "-" + i);
var newSegment = new Segment();
var source = new Source();
source.Text.Add(new CDataTag(para));
newSegment.Source = source;
paraUnit.Resources.Add(newSegment);
newGroup.Containers.Add(paraUnit);
}
var parentFile = unit.Parent as File;
if (parentFile != null)
{
parentFile.Containers.Add(newGroup);
parentFile.Containers.Remove(unit);
}
else
{
var parentGroup = unit.Parent as Group;
if (parentGroup != null)
{
parentGroup.Containers.Add(newGroup);
parentGroup.Containers.Remove(unit);
}
}
}
}
}
}
return(document);
}
public XliffDocument ExecuteMerge(XliffDocument document)
{
var units = document.CollapseChildren <Unit>();
foreach (var unit in units)
{
if (unit.Resources.Count > 1)
{
throw new InvalidOperationException("At this stage I expect only one segment. This unit is invalid: " + unit.SelectorPath);
}
Segment segment = unit.Resources[0] as Segment;
if (segment != null)
{
var hasSubFlow = segment.Source.Text.HasSubFlow() || segment.Target.Text.HasSubFlow();
ConvertToHtmlAndStore(segment.Source, subflows => SearchSubflowsInDocument(subflows, units, s => s.Source));
ConvertToHtmlAndStore(segment.Target, subflows => SearchSubflowsInDocument(subflows, units, s => s.Target));
if (hasSubFlow)
{
var group = unit.Parent as Group;
var newUnit = new Unit(unit.Id);
newUnit.Name = group.Name;
newUnit.Type = group.Type;
if (group.Metadata != null)
{
var newMetadataContainer = new MetadataContainer();
foreach (var metaGroup in group.Metadata.Groups)
{
var newMetaGroup = new MetaGroup();
newMetaGroup.Id = metaGroup.Id;
foreach (Meta item in metaGroup.Containers)
{
var newElement = new Meta(item.Type, item.NonTranslatableText);
newMetaGroup.Containers.Add(newElement);
}
newMetadataContainer.Groups.Add(newMetaGroup);
}
newUnit.Metadata = newMetadataContainer;
}
var newSegment = unit.Resources[0];
unit.Resources.Clear();
newUnit.Resources.Add(newSegment);
var parentFile = group.Parent as File;
if (parentFile != null)
{
var pos = parentFile.Containers.IndexOf(group);
parentFile.Containers.Insert(pos, newUnit);
parentFile.Containers.Remove(group);
}
else
{
var parentGroup = group.Parent as Group;
if (parentGroup != null)
{
var pos = parentGroup.Containers.IndexOf(group);
parentGroup.Containers.Insert(pos, newUnit);
parentGroup.Containers.Remove(group);
}
}
}
}
}
return(document);
}
public void RoundtripExample3()
{
var unit1 = new Unit("1");
var unit2 = new Unit("2");
var segment1 = new Segment(
new TextElement("Quetzal"),
new TextElement("Quetzal"));
var segment2 = new Segment(
new TextElement("An application to manipulate and process XLIFF documents"),
new TextElement("XLIFF 文書を編集、または処理 するアプリケーションです。"));
var grp = new MetaGroup();
unit1.Subunits.Add(segment1);
unit2.Subunits.Add(segment2);
var md = new Metadata();
md.Id = "md14";
unit1.Metadata = md;
var breakfast = new Metaitem("breakfast", "eggs");
var phase = new Metaitem("phase", "draft");
var version = new Metaitem("version", "3");
var grp2 = new MetaGroup();
grp2.Meta.Add(breakfast);
var grp1 = new MetaGroup();
grp1.Meta.Add(version);
grp1.Meta.Add(phase);
grp1.Meta.Add(grp2);
md.Groups.Add(grp1);
var model = new JliffDocument("en-US", "ja-JP");
model.Files.Add(new Localization.Jliff.Graph.File("f1"));
var test = new Metaitem("key", "value");
var test1 = new MetaGroup();
test1.Meta.Add(test);
var list = new List <MetaGroup>();
list.Add(test1);
model.Files[0].Metadata = list;
model.Files[0].Skeleton = new Skeleton("Graphic Example.psd.skl");
model.Files[0].Subfiles = new List <ISubfile>
{
unit1,
unit2
};
var dllPath = Assembly.GetAssembly(typeof(ModelTests)).Location;
var dllName = Assembly.GetAssembly(typeof(ModelTests)).GetName().Name;
var outputPath = dllPath.Replace(dllName + ".dll", "");
Converter.Serialize(Path.Combine(outputPath, "example3.json"), model);
Converter.Deserialize(new FileInfo(Path.Combine(outputPath, "example3.json")));
JsonSchema schema = JsonSchema.Parse(schemaDef);
var obGraph = JObject.FromObject(model);
Assert.IsTrue(obGraph.IsValid(schema));
}
