public static IEnumerable <Command> GetImmutableCollectionCommands(LanguageDefinition languageDefinition) { return(languageDefinition .Types .Where(f => f.HasTag(KnownTags.Collection) && f.HasTag(KnownTags.Immutable)) .Select(f => new ImmutableCollectionTypeCommand(f))); }
protected override void Execute(ExecutionContext context, Snippet snippet) { LanguageDefinition language = ((LanguageExecutionContext)context).Language; if (snippet.HasTag(KnownTags.Array)) { AddInitializer(context, snippet, language.GetArrayInitializer($"${LiteralIdentifiers.Value}$"), language.GetDefaultValue()); } else if (snippet.HasTag(KnownTags.Dictionary)) { AddInitializer(context, snippet, language.GetDictionaryInitializer($"${LiteralIdentifiers.Value}$"), language.GetDefaultValue()); } else if (snippet.HasTag(KnownTags.Collection)) { AddInitializer(context, snippet, language.GetCollectionInitializer($"${LiteralIdentifiers.Value}$"), language.GetDefaultValue()); } else if (snippet.HasTag(KnownTags.Variable)) { AddInitializer(context, snippet, language.GetVariableInitializer($"${LiteralIdentifiers.Value}$"), language.GetDefaultValue()); } else { AddInitializer(context, snippet, language.GetObjectInitializer($"${LiteralIdentifiers.Value}$"), "x"); } }
public PageViewModel( IPageConfiguration pageConfiguration, LanguageDefinition language, ContentViewModel contentViewModel, ContentLinksViewModel contentLinksViewModel) { if(pageConfiguration == null) { throw new ArgumentNullException(nameof(pageConfiguration)); } if (contentViewModel == null) { throw new ArgumentNullException(nameof(contentViewModel)); } if(contentLinksViewModel == null) { throw new ArgumentNullException(nameof(contentLinksViewModel)); } _pageConfiguration = pageConfiguration; Language = language; ContentViewModel = contentViewModel; ContentLinksViewModel = contentLinksViewModel; }
public void GetParameterValue_SentenceFinalPunctuationNR() { // Set up the punctuation for a Roman-script vernacular writing system. int hvoWs = Cache.DefaultVernWs; ILgWritingSystemFactory lgwsf = Cache.LanguageWritingSystemFactoryAccessor; IWritingSystem ws = lgwsf.get_EngineOrNull(hvoWs); LanguageDefinition langDef = new LanguageDefinition(ws); // We add the following Arabic punctuation: percent sign (066A), decimal separator (066B), // thousands separator (066C), five pointed star (066D), full stop (06D4), question mark (061F) langDef.PunctuationPatterns = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" + "<PunctuationPatterns>" + "<pattern value=\"\u066A \" context=\"WordFinal\" valid=\"true\" />" + "<pattern value=\"\u066B \" context=\"WordFinal\" valid=\"true\" />" + "<pattern value=\"\u066C \" context=\"WordFinal\" valid=\"true\" />" + "<pattern value=\"\u066D \" context=\"WordFinal\" valid=\"true\" />" + "<pattern value=\"\u06D4 \" context=\"WordFinal\" valid=\"true\" />" + "<pattern value=\"\u061F \" context=\"WordFinal\" valid=\"true\" /></PunctuationPatterns>"; // Get the sentence-final punctuation string sentenceFinalPunc = m_dataSource.GetParameterValue("SentenceFinalPunctuation"); // We expect that only sentence-final punctuation would be returned. Assert.AreEqual("\u06D4\u061F", sentenceFinalPunc); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Finds or creates the writing system. /// </summary> /// <param name="cache">The cache.</param> /// <param name="icuLocale">The icu locale.</param> /// <returns>The writing system</returns> /// ------------------------------------------------------------------------------------ private LgWritingSystem FindOrCreateWs(FdoCache cache, string icuLocale) { // Look to see if the writing system already exists in the database foreach (LgWritingSystem ws in cache.LanguageEncodings) { if (LanguageDefinition.SameLocale(ws.ICULocale, icuLocale)) { return(ws); } } // Create a new writing system based on the one noted in the XML file. // Load it in from the XML and save into the database. LanguageDefinitionFactory ldf = new LanguageDefinitionFactory(cache.LanguageWritingSystemFactoryAccessor, icuLocale); ldf.LanguageDefinition.SaveWritingSystem(icuLocale); cache.ResetLanguageEncodings(); // search again. It better be there now! foreach (LgWritingSystem ws in cache.LanguageEncodings) { if (LanguageDefinition.SameLocale(ws.ICULocale, icuLocale)) { return(ws); } } Debug.Assert(false); return(null); }
public void TestInitializeFromXml_NumericElementClosedTooEarly() { LanguageDefinition langDef = new LanguageDefinition(); langDef.LocaleName = "xmum"; langDef.LocaleScript = "IPA"; langDef.LocaleCountry = "usa"; langDef.LocaleVariant = "south"; langDef.ValidChars = ksXmlHeader + "<ValidCharacters><WordForming>e\uFFFCf\uFFFCg\uFFFCh</WordForming>" + "<Numeric/>4\uFFFC5" + "<Other>,\uFFFC!\uFFFC*</Other>" + "</ValidCharacters>"; ValidCharacters validChars = ValidCharacters.Load(langDef); ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars); Assert.AreEqual(4, validCharsW.WordFormingCharacters.Count); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("e")); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("f")); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("g")); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("h")); Assert.AreEqual(0, validCharsW.NumericCharacters.Count); Assert.AreEqual(3, validCharsW.OtherCharacters.Count); Assert.IsTrue(validCharsW.OtherCharacters.Contains(",")); Assert.IsTrue(validCharsW.OtherCharacters.Contains("!")); Assert.IsTrue(validCharsW.OtherCharacters.Contains("*")); }
public PageViewModel( IPageConfiguration pageConfiguration, LanguageDefinition language, ContentViewModel contentViewModel, ContentLinksViewModel contentLinksViewModel) { if (pageConfiguration == null) { throw new ArgumentNullException(nameof(pageConfiguration)); } if (contentViewModel == null) { throw new ArgumentNullException(nameof(contentViewModel)); } if (contentLinksViewModel == null) { throw new ArgumentNullException(nameof(contentLinksViewModel)); } _pageConfiguration = pageConfiguration; Language = language; ContentViewModel = contentViewModel; ContentLinksViewModel = contentLinksViewModel; }
public void SpawnFromDef(LanguageDefinition def) { DestroySpawned(); if (def == null) return; if (def.Data == null || def.Data.Count == 0) return; foreach (var pair in def.Data) { var spawn = Instantiate(Prefab, Content); spawn.NameInput.text = pair.Value.Key.Trim(); spawn.DescriptionInput.text = pair.Value.Desription.Trim(); spawn.Lock.isOn = pair.Value.Locked; string s = ""; // Make params string. for (int i = 0; i < pair.Value.Params.Length; i++) { string str = pair.Value.Params[i]; string sep = ",\n"; if (i == pair.Value.Params.Length - 1) sep = ""; s += str + sep; } spawn.ParamsInput.text = s; spawned.Add(spawn); } }
public void TestInitializeFromXml_BogusFormat() { LanguageDefinition langDef = new LanguageDefinition(); langDef.LocaleName = "xmum"; langDef.LocaleScript = "IPA"; langDef.LocaleCountry = "usa"; langDef.LocaleVariant = "south"; langDef.ValidChars = ksXmlHeader + "<ValidCharacters><WordForming>e\uFFFCf\uFFFCg\uFFFCh" + "</WordForming>" + "<Numeric>4\uFFFC5" + "<Other>,\uFFFC!\uFFFC*</Other>" + "</ValidCharacters>"; ValidCharacters validChars = ValidCharacters.Load(langDef); VerifyDefaultWordFormingCharacters(validChars); Exception e = (Exception)ReflectionHelper.GetField(typeof(ValidCharacters), "s_lastException"); Assert.AreEqual("Invalid ValidChars field while loading the xmum (IPA, usa, south) writing system:" + Environment.NewLine + "\t" + langDef.ValidChars + Environment.NewLine + "Parameter name: xmlSrc", e.Message); }
public static IEnumerable <Command> GetTypeCommands(LanguageDefinition languageDefinition) { return(languageDefinition .Types .Where(f => !f.HasTag(KnownTags.BasicType)) .Select(f => new TypeCommand(f))); }
public void GetParameterValue_SentenceFinalPunctuation() { // Set up the punctuation for a Roman-script vernacular writing system. int hvoWs = Cache.DefaultVernWs; ILgWritingSystemFactory lgwsf = Cache.LanguageWritingSystemFactoryAccessor; IWritingSystem ws = lgwsf.get_EngineOrNull(hvoWs); LanguageDefinition langDef = new LanguageDefinition(ws); // The test writing system has the following characters for punctuation: // .?!;-)(: langDef.PunctuationPatterns = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" + "<PunctuationPatterns>" + "<pattern value=\". \" context=\"WordFinal\" valid=\"true\" />" + "<pattern value=\"? \" context=\"WordFinal\" valid=\"true\" />" + "<pattern value=\"! \" context=\"WordFinal\" valid=\"true\" />" + "<pattern value=\"; \" context=\"WordFinal\" valid=\"true\" />" + "<pattern value=\"- \" context=\"WordFinal\" valid=\"true\" />" + "<pattern value=\") \" context=\"WordFinal\" valid=\"true\" />" + "<pattern value=\"( \" context=\"WordFinal\" valid=\"true\" />" + "<pattern value=\": \" context=\"WordFinal\" valid=\"true\" /></PunctuationPatterns>"; // Get the sentence-final punctuation string sentenceFinalPunc = m_dataSource.GetParameterValue("SentenceFinalPunctuation"); // We expect that only sentence-final punctuation would be returned. Assert.AreEqual(".?!", sentenceFinalPunc); }
public void TestInitializeFromXml_ValidAndBogusCharacters() { LanguageDefinition langDef = new LanguageDefinition(); langDef.LocaleName = "xmum"; langDef.LocaleScript = "IPA"; langDef.LocaleCountry = "usa"; langDef.LocaleVariant = "south"; langDef.ValidChars = ksXmlHeader + "<ValidCharacters><WordForming>\u05F6\uFFFCg\uFFFC\u05F7\uFFFCh</WordForming>" + "<Numeric>1</Numeric>" + "<Other></Other>" + "</ValidCharacters>"; ValidCharacters validChars = ValidCharacters.Load(langDef); ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars); Assert.AreEqual(2, validCharsW.WordFormingCharacters.Count); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("g")); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("h")); Assert.AreEqual(1, validCharsW.NumericCharacters.Count); Assert.IsTrue(validCharsW.NumericCharacters.Contains("1")); Assert.AreEqual(0, validCharsW.OtherCharacters.Count); Exception e = (Exception)ReflectionHelper.GetField(typeof(ValidCharacters), "s_lastException"); Assert.AreEqual("Invalid ValidChars field while loading the xmum (IPA, usa, south) writing system. " + "The following characters are invalid:" + Environment.NewLine + "\t\u05F6 (U+05F6)" + Environment.NewLine + "\t\u05F7 (U+05F7)" + Environment.NewLine + "Parameter name: xmlSrc", e.Message); }
public void GetDisplayNameNameOnly() { LanguageDefinition langDef = new LanguageDefinition(m_wsEn); langDef.LocaleName = "English"; Assert.AreEqual("English", langDef.DisplayName); }
public void SetPuaDefinitionsToNull() { LanguageDefinition langDef = new LanguageDefinition(m_wsEn); langDef.PuaDefinitions = new CharDef[] { new CharDef(0xF170, "COMBINING SNAKE BELOW;Mn;202;NSM;;;;") }; Assert.AreEqual(1, langDef.PuaDefinitionCount); langDef.PuaDefinitions = null; Assert.AreEqual(0, langDef.PuaDefinitionCount); }
public void GetDisplayNameNameAndCountry() { LanguageDefinition langDef = new LanguageDefinition(m_wsEn); langDef.LocaleName = "English"; langDef.LocaleCountry = "United States"; Assert.AreEqual("English (United States)", langDef.DisplayName); }
public void GetDisplayNameNameAndScript() { LanguageDefinition langDef = new LanguageDefinition(m_wsEn); langDef.LocaleName = "English"; langDef.LocaleScript = "Latin"; Assert.AreEqual("English (Latin)", langDef.DisplayName); }
public void SetAbbreviationsNameOnlyAddCountry() { LanguageDefinition langDef = new LanguageDefinition(m_wsEn); langDef.XmlWritingSystem.WritingSystem.IcuLocale = "en"; langDef.CountryAbbr = "US"; Assert.AreEqual("en_US", langDef.XmlWritingSystem.WritingSystem.IcuLocale); }
public void SetAbbreviationsNameOnlyAddVariant() { LanguageDefinition langDef = new LanguageDefinition(m_wsEn); langDef.XmlWritingSystem.WritingSystem.IcuLocale = "en"; langDef.VariantAbbr = "X_ETIC"; Assert.AreEqual("en__X_ETIC", langDef.XmlWritingSystem.WritingSystem.IcuLocale); }
public void SetAbbreviationsInsertCountry() { LanguageDefinition langDef = new LanguageDefinition(m_wsEn); langDef.XmlWritingSystem.WritingSystem.IcuLocale = "en__X_ETIC"; langDef.CountryAbbr = "UK"; Assert.AreEqual("en_UK_X_ETIC", langDef.XmlWritingSystem.WritingSystem.IcuLocale); }
public void SetAbbreviationsInsertScript() { LanguageDefinition langDef = new LanguageDefinition(m_wsEn); langDef.XmlWritingSystem.WritingSystem.IcuLocale = "en__X_ETIC"; langDef.ScriptAbbr = "Latn"; Assert.AreEqual("en_Latn__X_ETIC", langDef.XmlWritingSystem.WritingSystem.IcuLocale); }
public void GetDisplayNameNameAndVariant() { LanguageDefinition langDef = new LanguageDefinition(m_wsEn); langDef.LocaleName = "English"; langDef.LocaleVariant = "Phonetic"; Assert.AreEqual("English (Phonetic)", langDef.DisplayName); }
public static string Serialize(LanguageDefinition definition, Formatting formatting, bool serializeAsArrays = false) { //var json = JsonConvert.SerializeObject(definition, formatting, new InlineDefinitionJsonConverter(), new StringDefinitionJsonConverter(serializeAsArrays)); var settings = new JsonSerializerSettings();// {TypeNameHandling = TypeNameHandling.All}; settings.Converters.Add(new InlineDefinitionJsonConverter(serializeAsArrays)); settings.Converters.Add(new StringDefinitionJsonConverter(serializeAsArrays)); var json = JsonConvert.SerializeObject(definition, formatting, settings); return json; }
/// <summary> /// Create language UI presentation. /// </summary> /// <param name="language">The language to be presented</param> /// <param name="header">The header for a language value</param> public LanguageUIDefinition(LanguageDefinition language, string header) { if (string.IsNullOrWhiteSpace(header)) { throw new ArgumentException("Language header cannot be empty"); } Language = language; Header = header; }
public void GetAbbreviationsUnderline() { LanguageDefinition langDef = new LanguageDefinition(m_wsEn); langDef.XmlWritingSystem.WritingSystem.IcuLocale = "en_Latn_US_X_ETIC_x"; Assert.AreEqual("en", langDef.LocaleAbbr); Assert.AreEqual("Latn", langDef.ScriptAbbr); Assert.AreEqual("US", langDef.CountryAbbr); Assert.AreEqual("X_ETIC_X", langDef.VariantAbbr); }
public void GetAbbreviationsNameAndCountry() { LanguageDefinition langDef = new LanguageDefinition(m_wsEn); langDef.XmlWritingSystem.WritingSystem.IcuLocale = "en_US"; Assert.AreEqual("en", langDef.LocaleAbbr); Assert.AreEqual("US", langDef.CountryAbbr); Assert.AreEqual("", langDef.VariantAbbr); }
/// ---------------------------------------------------------------------------------------- /// <summary> /// For a given LanguageDefinition, if the ValidChars field is empty then try to get a set /// of ExemplarCharacters (valid characters) from ICU for this language. /// </summary> /// <param name="langDef"></param> /// <param name="cpe">A character property engine (needed for normalization).</param> /// ---------------------------------------------------------------------------------------- public static void TryLoadValidCharsIfEmpty(LanguageDefinition langDef, ILgCharacterPropertyEngine cpe) { //Try to load the ValidChars if none have been loaded yet. if (string.IsNullOrEmpty(langDef.ValidChars)) { string IcuLocale = (langDef.BaseLocale ?? langDef.LocaleAbbr); langDef.ValidChars = GetValidCharsForLocale(IcuLocale, cpe); } }
/// <summary> /// Get <see cref="PageViewModel"/> by language using content view model retrieval method. /// </summary> /// <param name="languageDefinition">Language.</param> /// <param name="contentViewModelMethod">Localized content retrieval method.</param> /// <returns>Page view model.</returns> private async Task <PageViewModel> GetPageViewModelByAsync(LanguageDefinition languageDefinition, Func <Task <ContentPublicViewData> > contentViewModelMethod) { var contentViewData = await contentViewModelMethod(); var linksData = await _contentRepository.GetContentLinksPresentationDataAsync(languageDefinition, Enum.GetNames(typeof(PredefinedPages)) ); return(new PageViewModel(_pageConfiguration, languageDefinition, contentViewData, linksData)); }
public void GetDisplayNameAll() { LanguageDefinition langDef = new LanguageDefinition(m_wsEn); langDef.LocaleName = "English"; langDef.LocaleScript = "Latin"; langDef.LocaleCountry = "United States"; langDef.LocaleVariant = "Phonetic"; Assert.AreEqual("English (Latin, United States, Phonetic)", langDef.DisplayName); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Looks up the ICU locale and returns the corresponding writing system code /// </summary> /// <param name="sICULocale">The ICU locale name</param> /// <returns>The Writing System code</returns> /// ------------------------------------------------------------------------------------ public int GetWsFromIcuLocale(string sICULocale) { foreach (ILgWritingSystem lgws in this) { if (LanguageDefinition.SameLocale(lgws.ICULocale, sICULocale)) { return(lgws.Hvo); } } return(0); // Couldn't find it. }
/// ------------------------------------------------------------------------------------ /// <summary> /// Loads the valid characters from the specified language definition into a new /// instance of the <see cref="ValidCharacters"/> class. /// </summary> /// ------------------------------------------------------------------------------------ public static ValidCharacters Load(LanguageDefinition langDef) { ValidCharacters validChars = Load(langDef.ValidChars, langDef.DisplayName, langDef); if (validChars != null) { validChars.InitSortComparer(langDef.IcuLocaleOriginal); } return(validChars); }
public static string Serialize(LanguageDefinition definition, Formatting formatting, bool serializeAsArrays = false) { //var json = JsonConvert.SerializeObject(definition, formatting, new InlineDefinitionJsonConverter(), new StringDefinitionJsonConverter(serializeAsArrays)); var settings = new JsonSerializerSettings();// {TypeNameHandling = TypeNameHandling.All}; settings.Converters.Add(new InlineDefinitionJsonConverter(serializeAsArrays)); settings.Converters.Add(new StringDefinitionJsonConverter(serializeAsArrays)); var json = JsonConvert.SerializeObject(definition, formatting, settings); return(json); }
public void SetsProperLanguage( string language, LanguageDefinition expectedModelLanguage) { SetupContent(); var result = _homeController.Index(language) as ViewResult; var resultModel = result.ViewData.Model as PageViewModel; Assert.Equal(expectedModelLanguage, resultModel.Language); }
public ContentLinksViewModel( LanguageDefinition linksLanguage, IDictionary<string, LinkUI> internalNamesToLinksUI) { if(internalNamesToLinksUI == null) { throw new ArgumentNullException(nameof(internalNamesToLinksUI)); } _internalNamesToLinksUI = internalNamesToLinksUI; _linksLanguage = linksLanguage; }
public ContentViewModel FindTranslatedContentByInternalCaption(LanguageDefinition langDefinition, string internalCaption) { GuardNotDisposed(); var contentAndTranslation = (from x in _dataDbContext.Translations join c in _dataDbContext.Contents on new { Id = x.ContentId, Caption = internalCaption } equals new { Id = c.Id, Caption = c.InternalCaption } where x.Version == langDefinition && x.State == DataAvailabilityState.published let urlNames = (from y in c.Translations where y.State == DataAvailabilityState.published select new { y.Version, y.UrlName }).ToDictionary(z => z.Version, z => z.UrlName) select FillContentViewModel(c.InternalCaption, x, urlNames)).FirstOrDefault(); return contentAndTranslation; }
public ContentViewModel FindTranslatedContentByUrlName(LanguageDefinition langDefinition, string urlName) { GuardNotDisposed(); var lowerCaseUrlName = urlName.ToLowerInvariant(); var contentAndTranslation = (from x in _dataDbContext.Translations join c in _dataDbContext.Contents on x.ContentId equals c.Id where x.Version == langDefinition && x.UrlName == lowerCaseUrlName && x.State == DataAvailabilityState.published let urlNames = (from y in c.Translations where y.State == DataAvailabilityState.published select new { y.Version, y.UrlName }).ToDictionary(z => z.Version, z => z.UrlName) select FillContentViewModel(c.InternalCaption, x, urlNames)).FirstOrDefault(); return contentAndTranslation; }
private PageViewModel GetPageViewModelBy(LanguageDefinition languageDefinition, Func<ContentViewModel> contentViewModelMethod) { GuardNotDisposed(); ContentViewModel contentVM; ContentLinksViewModel linksVM; using (_contentRepository) { contentVM = contentViewModelMethod(); if (contentVM == null) { return null; // No content available. } linksVM = _contentRepository.GetContentLinksPresentationData(languageDefinition, Enum.GetNames(typeof(PredefinedPages)) ); } return new PageViewModel(_pageConfiguration, languageDefinition, contentVM, linksVM); }
public ContentLinksViewModel GetContentLinksPresentationData(LanguageDefinition languageDefinition, IList<string> internalContentNames) { GuardNotDisposed(); var internalNamesToLinkViewModels = (from t in _dataDbContext.Translations join c in _dataDbContext.Contents on t.ContentId equals c.Id where internalContentNames.Contains(c.InternalCaption) && t.State == DataAvailabilityState.published && t.Version == languageDefinition select new { LinkUI = new LinkUI { LinkTitle = t.Title, UrlName = t.UrlName }, InternalCaption = c.InternalCaption }).ToDictionary(x => x.InternalCaption, x => x.LinkUI); return new ContentLinksViewModel( languageDefinition, internalNamesToLinkViewModels); }
public static string Serialize(LanguageDefinition definition, bool serializeAsArrays = false) { return Serialize(definition, Formatting.Indented, serializeAsArrays); }
public string LanguageDefinitionToLanguageRepresentation(LanguageDefinition definition) { return _languageDefinitionToRepresentations[definition]; }
public CultureInfo LanguageDefinitionToCultureInfo(LanguageDefinition languageDefinition) { return _languageDefinitionToCultureInfo[languageDefinition]; }
/// <summary> /// Get translated page by its translated human-readable name. /// </summary> /// <param name="languageDefinition">Required language definition.</param> /// <param name="urlName">Human-readable name of a content.</param> /// <returns><typeparamref name="PageViewModel"/> instance</returns> public PageViewModel GetPageByHumanReadableName(LanguageDefinition languageDefinition, string urlName) { return GetPageViewModelBy(languageDefinition, () => _contentRepository.FindTranslatedContentByUrlName(languageDefinition, urlName)); }
/// <summary> /// Get translated page by its internal caption. /// </summary> /// <param name="languageDefinition">Required language definition.</param> /// <param name="internalCaption">Internal caption of a content.</param> /// <returns><typeparamref name="PageViewModel"/> instance</returns> public PageViewModel GetPageByInternalCaption(LanguageDefinition languageDefinition, string internalCaption) { return GetPageViewModelBy(languageDefinition, () => _contentRepository.FindTranslatedContentByInternalCaption(languageDefinition, internalCaption)); }