public void New_TrainWithInitialPredictor()
{
using (var env = new LocalEnvironment(seed: 1, conc: 1))
{
var data = new TextLoader(env, MakeSentimentTextLoaderArgs()).Read(new MultiFileSource(GetDataPath(TestDatasets.Sentiment.trainFilename)));
// Pipeline.
var pipeline = new TextTransform(env, "SentimentText", "Features");
// Train the pipeline, prepare train set.
var trainData = pipeline.FitAndTransform(data);
// Train the first predictor.
var trainer = new LinearClassificationTrainer(env, new LinearClassificationTrainer.Arguments
{
NumThreads = 1
}, "Features", "Label");
var firstModel = trainer.Fit(trainData);
// Train the second predictor on the same data.
var secondTrainer = new AveragedPerceptronTrainer(env, new AveragedPerceptronTrainer.Arguments());
var trainRoles = new RoleMappedData(trainData, label: "Label", feature: "Features");
var finalModel = secondTrainer.Train(new TrainContext(trainRoles, initialPredictor: firstModel.Model));
}
}
public static string Transform(this string str, TextTransform textTransform)
{
if (str == null)
{
return(null);
}
switch (textTransform)
{
case TextTransform.None:
return(str);
case TextTransform.ToLower:
return(str.ToLowerInvariant());
case TextTransform.ToUpper:
return(str.ToUpperInvariant());
case TextTransform.ToPascalNamingConvention:
return(str.ToPascalNamingConvention());
case TextTransform.ToUnderscoreLowerCaseNamingConvention:
return(str.ToUnderscoreLowerCaseNamingConvention());
case TextTransform.ToUnderscoreUpperCaseNamingConvention:
return(str.ToUnderscoreUpperCaseNamingConvention());
default:
throw new NotImplementedException();
}
}
public void TrainWithValidationSet()
{
var dataPath = GetDataPath(SentimentDataPath);
var validationDataPath = GetDataPath(SentimentTestPath);
using (var env = new TlcEnvironment(seed: 1, conc: 1))
{
// Pipeline
var loader = new TextLoader(env, MakeSentimentTextLoaderArgs(), new MultiFileSource(dataPath));
var trans = TextTransform.Create(env, MakeSentimentTextTransformArgs(), loader);
var trainData = trans;
// Apply the same transformations on the validation set.
// Sadly, there is no way to easily apply the same loader to different data, so we either have
// to create another loader, or to save the loader to model file and then reload.
// A new one is not always feasible, but this time it is.
var validLoader = new TextLoader(env, MakeSentimentTextLoaderArgs(), new MultiFileSource(validationDataPath));
var validData = ApplyTransformUtils.ApplyAllTransformsToData(env, trainData, validLoader);
// Cache both datasets.
var cachedTrain = new CacheDataView(env, trainData, prefetch: null);
var cachedValid = new CacheDataView(env, validData, prefetch: null);
// Train.
var trainer = new FastTreeBinaryClassificationTrainer(env, new FastTreeBinaryClassificationTrainer.Arguments
{
NumTrees = 3
});
var trainRoles = new RoleMappedData(cachedTrain, label: "Label", feature: "Features");
var validRoles = new RoleMappedData(cachedValid, label: "Label", feature: "Features");
trainer.Train(new Runtime.TrainContext(trainRoles, validRoles));
}
}
void New_CrossValidation()
{
var dataPath = GetDataPath(SentimentDataPath);
var testDataPath = GetDataPath(SentimentTestPath);
using (var env = new TlcEnvironment(seed: 1, conc: 1))
{
var data = new TextLoader(env, MakeSentimentTextLoaderArgs())
.Read(new MultiFileSource(dataPath));
// Pipeline.
var pipeline = new TextTransform(env, "SentimentText", "Features")
.Append(new LinearClassificationTrainer(env, new LinearClassificationTrainer.Arguments
{
NumThreads = 1,
ConvergenceTolerance = 1f
}, "Features", "Label"));
var cv = new MyCrossValidation.BinaryCrossValidator(env)
{
NumFolds = 2
};
var cvResult = cv.CrossValidate(data, pipeline);
}
}
public void SetupSentimentPipeline()
{
_sentimentExample = new SentimentData()
{
SentimentText = "Not a big fan of this."
};
string _sentimentDataPath = Program.GetInvariantCultureDataPath("wikipedia-detox-250-line-data.tsv");
using (var env = new ConsoleEnvironment(seed: 1, conc: 1, verbose: false, sensitivity: MessageSensitivity.None, outWriter: EmptyWriter.Instance))
{
var reader = new TextLoader(env,
new TextLoader.Arguments()
{
Separator = "\t",
HasHeader = true,
Column = new[]
{
new TextLoader.Column("Label", DataKind.BL, 0),
new TextLoader.Column("SentimentText", DataKind.Text, 1)
}
});
IDataView data = reader.Read(new MultiFileSource(_sentimentDataPath));
var pipeline = new TextTransform(env, "SentimentText", "Features")
.Append(new LinearClassificationTrainer(env, "Features", "Label", advancedSettings: (s) => { s.NumThreads = 1; s.ConvergenceTolerance = 1e-2f; }));
var model = pipeline.Fit(data);
_sentimentModel = model.MakePredictionFunction <SentimentData, SentimentPrediction>(env);
}
}
void New_MultithreadedPrediction()
{
var dataPath = GetDataPath(SentimentDataPath);
var testDataPath = GetDataPath(SentimentTestPath);
using (var env = new TlcEnvironment(seed: 1, conc: 1))
{
var reader = new TextLoader(env, MakeSentimentTextLoaderArgs());
var data = reader.Read(new MultiFileSource(dataPath));
// Pipeline.
var pipeline = new TextTransform(env, "SentimentText", "Features")
.Append(new LinearClassificationTrainer(env, new LinearClassificationTrainer.Arguments {
NumThreads = 1
}, "Features", "Label"));
// Train.
var model = pipeline.Fit(data);
// Create prediction engine and test predictions.
var engine = new MyPredictionEngine <SentimentData, SentimentPrediction>(env, model);
// Take a couple examples out of the test data and run predictions on top.
var testData = reader.Read(new MultiFileSource(GetDataPath(SentimentTestPath)))
.AsEnumerable <SentimentData>(env, false);
Parallel.ForEach(testData, (input) =>
{
lock (engine)
{
var prediction = engine.Predict(input);
}
});
}
}
public void AutoNormalizationAndCaching()
{
var dataPath = GetDataPath(SentimentDataPath);
var testDataPath = GetDataPath(SentimentTestPath);
using (var env = new TlcEnvironment(seed: 1, conc: 1))
{
// Pipeline.
var loader = new TextLoader(env, MakeSentimentTextLoaderArgs(), new MultiFileSource(dataPath));
var trans = TextTransform.Create(env, MakeSentimentTextTransformArgs(false), loader);
// Train.
var trainer = new LinearClassificationTrainer(env, new LinearClassificationTrainer.Arguments
{
NumThreads = 1,
ConvergenceTolerance = 1f
});
// Auto-caching.
IDataView trainData = trainer.Info.WantCaching ? (IDataView) new CacheDataView(env, trans, prefetch: null) : trans;
var trainRoles = new RoleMappedData(trainData, label: "Label", feature: "Features");
// Auto-normalization.
NormalizeTransform.CreateIfNeeded(env, ref trainRoles, trainer);
var predictor = trainer.Train(new Runtime.TrainContext(trainRoles));
}
}
public static NSAttributedString ToNSAttributedString(
this FormattedString formattedString,
IFontManager fontManager,
double defaultLineHeight = 0d, // TODO: NET7 should be -1, but too late to change for net6
TextAlignment defaultHorizontalAlignment = TextAlignment.Start,
Font?defaultFont = null,
Color?defaultColor = null,
TextTransform defaultTextTransform = TextTransform.Default)
{
if (formattedString == null)
{
return(new NSAttributedString(string.Empty));
}
var attributed = new NSMutableAttributedString();
for (int i = 0; i < formattedString.Spans.Count; i++)
{
Span span = formattedString.Spans[i];
if (span.Text == null)
{
continue;
}
attributed.Append(span.ToNSAttributedString(fontManager, defaultLineHeight, defaultHorizontalAlignment, defaultFont, defaultColor, defaultTextTransform));
}
return(attributed);
}
public override void Execute(CommandContext context, CallerContext callerContext, ChatUser callingUser, string[] args)
{
if (context.Repository.Users.Count() == 1)
{
throw new InvalidOperationException("You're the only person in here...");
}
if (args.Length == 0 || String.IsNullOrWhiteSpace(args[0]))
{
throw new InvalidOperationException("Who are you trying send a private message to?");
}
var toUserName = HttpUtility.HtmlDecode(args[0]);
ChatUser toUser = context.Repository.VerifyUser(toUserName);
if (toUser == callingUser)
{
throw new InvalidOperationException("You can't private message yourself!");
}
string messageText = String.Join(" ", args.Skip(1)).Trim();
if (String.IsNullOrEmpty(messageText))
{
throw new InvalidOperationException(String.Format("What did you want to say to '{0}'?", toUser.Name));
}
HashSet <string> urls;
var transform = new TextTransform(context.Repository);
messageText = transform.Parse(messageText);
messageText = TextTransform.TransformAndExtractUrls(messageText, out urls);
context.NotificationService.SendPrivateMessage(callingUser, toUser, messageText);
}
void FileBasedSavingOfData()
{
var dataPath = GetDataPath(SentimentDataPath);
var testDataPath = GetDataPath(SentimentTestPath);
using (var env = new TlcEnvironment(seed: 1, conc: 1))
{
// Pipeline
var loader = new TextLoader(env, MakeSentimentTextLoaderArgs(), new MultiFileSource(dataPath));
var trans = TextTransform.Create(env, MakeSentimentTextTransformArgs(), loader);
var saver = new BinarySaver(env, new BinarySaver.Arguments());
using (var ch = env.Start("SaveData"))
using (var file = env.CreateOutputFile("i.idv"))
{
DataSaverUtils.SaveDataView(ch, saver, trans, file);
}
var binData = new BinaryLoader(env, new BinaryLoader.Arguments(), new MultiFileSource("i.idv"));
var trainRoles = new RoleMappedData(binData, label: "Label", feature: "Features");
var trainer = new LinearClassificationTrainer(env, new LinearClassificationTrainer.Arguments
{
NumThreads = 1
});
var predictor = trainer.Train(new Runtime.TrainContext(trainRoles));
DeleteOutputPath("i.idv");
}
}
public void New_SimpleTrainAndPredict()
{
var dataPath = GetDataPath(SentimentDataPath);
var testDataPath = GetDataPath(SentimentTestPath);
using (var env = new TlcEnvironment(seed: 1, conc: 1))
{
var reader = new TextLoader(env, MakeSentimentTextLoaderArgs());
var data = reader.Read(new MultiFileSource(dataPath));
// Pipeline.
var pipeline = new TextTransform(env, "SentimentText", "Features")
.Append(new LinearClassificationTrainer(env, new LinearClassificationTrainer.Arguments {
NumThreads = 1
}, "Features", "Label"));
// Train.
var model = pipeline.Fit(data);
// Create prediction engine and test predictions.
var engine = model.MakePredictionFunction <SentimentData, SentimentPrediction>(env);
// Take a couple examples out of the test data and run predictions on top.
var testData = reader.Read(new MultiFileSource(GetDataPath(SentimentTestPath)))
.AsEnumerable <SentimentData>(env, false);
foreach (var input in testData.Take(5))
{
var prediction = engine.Predict(input);
// Verify that predictions match and scores are separated from zero.
Assert.Equal(input.Sentiment, prediction.Sentiment);
Assert.True(input.Sentiment && prediction.Score > 1 || !input.Sentiment && prediction.Score < -1);
}
}
}
public void TrainWithInitialPredictor()
{
var dataPath = GetDataPath(SentimentDataPath);
using (var env = new TlcEnvironment(seed: 1, conc: 1))
{
// Pipeline
var loader = new TextLoader(env, MakeSentimentTextLoaderArgs(), new MultiFileSource(dataPath));
var trans = TextTransform.Create(env, MakeSentimentTextTransformArgs(), loader);
var trainData = trans;
var cachedTrain = new CacheDataView(env, trainData, prefetch: null);
// Train the first predictor.
var trainer = new LinearClassificationTrainer(env, new LinearClassificationTrainer.Arguments
{
NumThreads = 1
});
var trainRoles = new RoleMappedData(cachedTrain, label: "Label", feature: "Features");
var predictor = trainer.Train(new Runtime.TrainContext(trainRoles));
// Train the second predictor on the same data.
var secondTrainer = new AveragedPerceptronTrainer(env, new AveragedPerceptronTrainer.Arguments());
var finalPredictor = secondTrainer.Train(new TrainContext(trainRoles, initialPredictor: predictor));
}
}
public void New_ReconfigurablePrediction()
{
var dataPath = GetDataPath(SentimentDataPath);
var testDataPath = GetDataPath(SentimentTestPath);
using (var env = new TlcEnvironment(seed: 1, conc: 1))
{
var dataReader = new TextLoader(env, MakeSentimentTextLoaderArgs());
var data = dataReader.Read(new MultiFileSource(dataPath));
var testData = dataReader.Read(new MultiFileSource(testDataPath));
// Pipeline.
var pipeline = new TextTransform(env, "SentimentText", "Features")
.Fit(data);
var trainer = new LinearClassificationTrainer(env, new LinearClassificationTrainer.Arguments {
NumThreads = 1
}, "Features", "Label");
var trainData = pipeline.Transform(data);
var model = trainer.Fit(trainData);
var scoredTest = model.Transform(pipeline.Transform(testData));
var metrics = new MyBinaryClassifierEvaluator(env, new BinaryClassifierEvaluator.Arguments()).Evaluate(scoredTest, "Label", "Probability");
var newModel = new BinaryPredictionTransformer <IPredictorProducing <float> >(env, model.Model, trainData.Schema, model.FeatureColumn, threshold: 0.01f, thresholdColumn: DefaultColumnNames.Probability);
var newScoredTest = newModel.Transform(pipeline.Transform(testData));
var newMetrics = new MyBinaryClassifierEvaluator(env, new BinaryClassifierEvaluator.Arguments {
Threshold = 0.01f, UseRawScoreThreshold = false
}).Evaluate(newScoredTest, "Label", "Probability");
}
}
private string ParseChatMessageText(string content, out HashSet <string> links)
{
var textTransform = new TextTransform(_repository);
string message = textTransform.Parse(content);
return(Transform(message, out links));
}
private void HandleMsg(ChatUser user, string[] parts)
{
if (_repository.Users.Count() == 1)
{
throw new InvalidOperationException("You're the only person in here...");
}
if (parts.Length < 2 || String.IsNullOrWhiteSpace(parts[1]))
{
throw new InvalidOperationException("Who are you trying send a private message to?");
}
var toUserName = parts[1];
ChatUser toUser = _repository.VerifyUser(toUserName);
if (toUser == user)
{
throw new InvalidOperationException("You can't private message yourself!");
}
string messageText = String.Join(" ", parts.Skip(2)).Trim();
if (String.IsNullOrEmpty(messageText))
{
throw new InvalidOperationException(String.Format("What did you want to say to '{0}'.", toUser.Name));
}
HashSet <string> urls;
var transform = new TextTransform(_repository);
messageText = transform.Parse(messageText);
messageText = TextTransform.TransformAndExtractUrls(messageText, out urls);
_notificationService.SendPrivateMessage(user, toUser, messageText);
}
public void TextContainsSymbols_Test()
{
Assert.False(TextTransform.CheckTextContainsSymbols("", Symbol.Brackets));
Assert.False(TextTransform.CheckTextContainsSymbols("Hello, world!", Symbol.Quotes));
Assert.True(TextTransform.CheckTextContainsSymbols("Hell(o)", Symbol.Brackets));
Assert.True(TextTransform.CheckTextContainsSymbols("Organization name: «Pomoika Inc»", Symbol.Quotes));
Assert.True(TextTransform.CheckTextContainsSymbols("Organization name: \"Pomoika Inc\"", Symbol.Quotes));
}
public void ReplaceSubstringInText_Test()
{
Assert.Equal("", TextTransform.RemoveTextBetweenSymbols("", Symbol.Brackets));
Assert.Equal("Hello, world!", TextTransform.RemoveTextBetweenSymbols("Hello, world!", Symbol.Quotes));
Assert.Equal("Hell(1)", TextTransform.RemoveTextBetweenSymbols("Hell(o)", Symbol.Brackets));
Assert.Equal("Organization name: «11»", TextTransform.RemoveTextBetweenSymbols("Organization name: «Pomoika Inc»", Symbol.Quotes));
Assert.Equal("Organization name: \"11\"", TextTransform.RemoveTextBetweenSymbols("Organization name: \"Pomoika Inc\"", Symbol.Quotes));
}
public TransformWrapper Fit(IDataView input)
{
var xf = TextTransform.Create(_env, _args, input);
var empty = new EmptyDataView(_env, input.Schema);
var chunk = ApplyTransformUtils.ApplyAllTransformsToData(_env, xf, empty, input);
return(new TransformWrapper(_env, chunk));
}
public void StringWithHashtagButRoomDoesntExistDoesNotModifyMessage()
{
IJabbrRepository repository = CreateRoomRepository();
TextTransform transform = new TextTransform(repository);
string result = transform.Parse("#thisdoesnotexist");
Assert.Equal("#thisdoesnotexist", result);
}
private string ConvertUrlsAndRoomLinks(string message)
{
TextTransform textTransform = new TextTransform(_repository);
message = textTransform.ConvertHashtagsToRoomLinks(message);
HashSet <string> urls;
return(TextTransform.TransformAndExtractUrls(message, out urls));
}
public async Task InitialTextTransformApplied(string text, TextTransform transform, string expected)
{
var control = new Editor()
{
Text = text, TextTransform = transform
};
var platformText = await GetPlatformText(await CreateHandlerAsync <EditorHandler>(control));
Assert.Equal(expected, platformText);
}
public void StringWithHashtagModifiesHashtagToRoomLink()
{
IJabbrRepository repository = CreateRoomRepository();
string expected = "<a href=\"#/rooms/hashtag\" title=\"#hashtag\">#hashtag</a>";
TextTransform transform = new TextTransform(repository);
string result = transform.Parse("#hashtag");
Assert.Equal(expected, result);
}
public Style(string fontName, UnitPx fontSize, FontWeight fontWeight, FontStyle fontStyle, TextTransform textTransform, TextDecoration textDecoration, Color color)
{
this.FontName = fontName;
this.FontSize = fontSize;
this.FontWeight = fontWeight;
this.FontStyle = fontStyle;
this.TextTransform = textTransform;
this.TextDecoration = textDecoration == TextDecoration.Inherit? TextDecoration.None: textDecoration;
this.Color = color;
}
void ReconfigurablePrediction()
{
var dataPath = GetDataPath(SentimentDataPath);
var testDataPath = GetDataPath(SentimentTestPath);
using (var env = new TlcEnvironment(seed: 1, conc: 1))
{
// Pipeline
var loader = new TextLoader(env, MakeSentimentTextLoaderArgs(), new MultiFileSource(dataPath));
var trans = TextTransform.Create(env, MakeSentimentTextTransformArgs(), loader);
// Train
var trainer = new LinearClassificationTrainer(env, new LinearClassificationTrainer.Arguments
{
NumThreads = 1
});
var cached = new CacheDataView(env, trans, prefetch: null);
var trainRoles = new RoleMappedData(cached, label: "Label", feature: "Features");
IPredictor predictor = trainer.Train(new Runtime.TrainContext(trainRoles));
using (var ch = env.Start("Calibrator training"))
{
predictor = CalibratorUtils.TrainCalibrator(env, ch, new PlattCalibratorTrainer(env), int.MaxValue, predictor, trainRoles);
}
var scoreRoles = new RoleMappedData(trans, label: "Label", feature: "Features");
IDataScorerTransform scorer = ScoreUtils.GetScorer(predictor, scoreRoles, env, trainRoles.Schema);
var dataEval = new RoleMappedData(scorer, label: "Label", feature: "Features", opt: true);
var evaluator = new BinaryClassifierMamlEvaluator(env, new BinaryClassifierMamlEvaluator.Arguments()
{
});
var metricsDict = evaluator.Evaluate(dataEval);
var metrics = BinaryClassificationMetrics.FromMetrics(env, metricsDict["OverallMetrics"], metricsDict["ConfusionMatrix"])[0];
var bindable = ScoreUtils.GetSchemaBindableMapper(env, predictor, null);
var mapper = bindable.Bind(env, trainRoles.Schema);
var newScorer = new BinaryClassifierScorer(env, new BinaryClassifierScorer.Arguments {
Threshold = 0.01f, ThresholdColumn = DefaultColumnNames.Probability
},
scoreRoles.Data, mapper, trainRoles.Schema);
dataEval = new RoleMappedData(newScorer, label: "Label", feature: "Features", opt: true);
var newEvaluator = new BinaryClassifierMamlEvaluator(env, new BinaryClassifierMamlEvaluator.Arguments()
{
Threshold = 0.01f, UseRawScoreThreshold = false
});
metricsDict = newEvaluator.Evaluate(dataEval);
var newMetrics = BinaryClassificationMetrics.FromMetrics(env, metricsDict["OverallMetrics"], metricsDict["ConfusionMatrix"])[0];
}
}
public void LabelTextTransform(TextTransform result)
{
var xaml = @"
<Label
xmlns=""http://schemas.microsoft.com/dotnet/2021/maui""
xmlns:x=""http://schemas.microsoft.com/winfx/2006/xaml"" TextTransform=""" + result + @""" />";
var label = new Label().LoadFromXaml(xaml);
Assert.AreEqual(result, label.TextTransform);
}
public static void UpdateInlines(
this TextBlock textBlock,
IFontManager fontManager,
FormattedString formattedString,
double defaultLineHeight = 0d, // TODO: NET7 should be -1, but too late to change for net6
TextAlignment defaultHorizontalAlignment = TextAlignment.Start,
Font?defaultFont = null,
Color?defaultColor = null,
TextTransform defaultTextTransform = TextTransform.Default)
{
textBlock.Inlines.Clear();
// Have to implement a measure here, otherwise inline.ContentStart and ContentEnd will be null, when used in RecalculatePositions
textBlock.Measure(new global::Windows.Foundation.Size(double.MaxValue, double.MaxValue));
var runAndColorTuples = formattedString.ToRunAndColorsTuples(fontManager, defaultLineHeight, defaultHorizontalAlignment, defaultFont, defaultColor, defaultTextTransform);
var heights = new List <double>();
int currentTextIndex = 0;
foreach (var runAndColorTuple in runAndColorTuples)
{
Run run = runAndColorTuple.Item1;
Color textColor = runAndColorTuple.Item2;
Color background = runAndColorTuple.Item3;
heights.Add(textBlock.FindDefaultLineHeight(run));
textBlock.Inlines.Add(run);
int length = run.Text.Length;
if (background != null || textColor != null)
{
TextHighlighter textHighlighter = new TextHighlighter {
Ranges = { new TextRange(currentTextIndex, length) }
};
if (background != null)
{
textHighlighter.Background = background.ToPlatform();
}
else
{
textHighlighter.Background = Colors.Transparent.ToPlatform();
}
if (textColor != null)
{
textHighlighter.Foreground = textColor.ToPlatform();
}
textBlock.TextHighlighters.Add(textHighlighter);
}
currentTextIndex += length;
}
}
public void UrlWithHttpsIsTransformed()
{
//arrange
var message = "message https://www.jabbr.net continues on";
HashSet <string> extractedUrls;
//act
var result = TextTransform.TransformAndExtractUrls(message, out extractedUrls);
//assert
Assert.Equal("message <a rel=\"nofollow external\" target=\"_blank\" href=\"https://www.jabbr.net\" title=\"https://www.jabbr.net\">https://www.jabbr.net</a> continues on", result);
}
public void LabelTextTransform(TextTransform result)
{
var xaml = @"
<Label
xmlns=""http://xamarin.com/schemas/2014/forms""
xmlns:x=""http://schemas.microsoft.com/winfx/2006/xaml"" TextTransform=""" + result + @""" />";
Device.PlatformServices = new MockPlatformServices();
var label = new Label().LoadFromXaml(xaml);
Assert.AreEqual(result, label.TextTransform);
}
public void UrlEndsWithSlashInsideAQuotedSentence()
{
//arrange
var message = "\"Visit http://www.jabbr.net/\"";
HashSet <string> extractedUrls;
//act
var result = TextTransform.TransformAndExtractUrls(message, out extractedUrls);
//assert
Assert.Equal("\"Visit <a rel=\"nofollow external\" target=\"_blank\" href=\"http://www.jabbr.net/\" title=\"http://www.jabbr.net/\">http://www.jabbr.net/</a>\"", result);
}
public void UrlInsideAQuotedSentence()
{
//arrange
var message = "This is a sentence with quotes and a url ... see \"http://foo.com\"";
HashSet <string> extractedUrls;
//act
var result = TextTransform.TransformAndExtractUrls(message, out extractedUrls);
//assert
Assert.Equal("This is a sentence with quotes and a url ... see \"<a rel=\"nofollow external\" target=\"_blank\" href=\"http://foo.com\" title=\"http://foo.com\">http://foo.com</a>\"", result);
}
/// <summary>
/// Initializes a new instance of the <see cref="FriendlyUrlSettings"/> class.
/// </summary>
/// <param name="config">The config.</param>
public FriendlyUrlSettings(NameValueCollection config)
{
if (config == null)
return;
textTransformation = ParseTextTransform(config["textTransform"]);
separatingCharacter = config["separatingCharacter"];
string wordCountLimitText = config["limitWordCount"];
if(!String.IsNullOrEmpty(wordCountLimitText) )
{
int.TryParse(wordCountLimitText, out this.wordCountLimit);
}
enabled = true;
}
public CssStyle()
{
color= new Color(0, 0, 0);
background= new Background();
border= new Border();
clear= FloatType.none;
display= Display.inline;
_float= FloatType.none;
height= new FlexibleFloat(0f, FlexFloatType.px);
margin= new Margin(0f, 0f, 0f, 0f);
padding= new Padding(0f, 0f, 0f, 0f);
width= new FlexibleFloat(100f, FlexFloatType.percentage);
letterSpacing= new FlexibleFloat(FlexibleFloat.letterSpacingNormal, FlexFloatType.px);
lineHeight= new FlexibleFloat(FlexibleFloat.lineHeightNormal, FlexFloatType.px);
textAlign= TextAlignment.left;
textIndex= new FlexibleFloat(0f, FlexFloatType.px);
textTransform= TextTransform.none;
whiteSpace= WhiteSpace.normal;
wordSpacing= new FlexibleFloat(FlexibleFloat.wordSpacingNormal, FlexFloatType.px);
textDecoration= TextDecoration.none;
font= new Sdx.Font("arial", 14);
listStyle= new ListStyle();
}
/// <summary>
/// Converts a title of a blog post into a friendly, but URL safe string.
/// Defaults entryId to 0 as if it was a new entry
/// </summary>
/// <param name="title">The original title of the blog post.</param>
/// <param name="wordSeparator">The string used to separate words in the title.</param>
/// <param name="textTransform">Used to specify a change to the casing of the string.</param>
/// <returns></returns>
public static string AutoGenerateFriendlyUrl(string title, char wordSeparator, TextTransform textTransform)
{
return AutoGenerateFriendlyUrl(title, wordSeparator, 0, textTransform);
}
/// <summary>
/// Converts a title of a blog post into a friendly, but URL safe string.
/// </summary>
/// <param name="title">The original title of the blog post.</param>
/// <param name="wordSeparator">The string used to separate words in the title.</param>
/// <param name="entryId">The id of the current entry.</param>
/// <param name="textTransform">Used to specify a change to the casing of the string.</param>
/// <returns></returns>
public static string AutoGenerateFriendlyUrl(string title, char wordSeparator, int entryId, TextTransform textTransform)
{
if (title == null)
{
throw new ArgumentNullException("title", "Cannot generate friendly url from null title.");
}
string entryName = RemoveNonWordCharacters(title);
entryName = ReplaceSpacesWithSeparator(entryName, wordSeparator);
entryName = ReplaceUnicodeCharacters(entryName);
entryName = HttpUtility.UrlEncode(entryName);
entryName = RemoveTrailingPeriods(entryName);
entryName = entryName.Trim(new char[] {wordSeparator});
entryName = StringHelper.RemoveDoubleCharacter(entryName, '.');
if (wordSeparator != char.MinValue && wordSeparator != '.')
entryName = StringHelper.RemoveDoubleCharacter(entryName, wordSeparator);
if (StringHelper.IsNumeric(entryName))
{
entryName = "n" + wordSeparator + entryName;
}
string newEntryName = FriendlyUrlSettings.TransformString(entryName, textTransform);
int tryCount = 0;
Entry currentEntry = ObjectProvider.Instance().GetEntry(newEntryName, false, false);
while (currentEntry != null)
{
if (currentEntry.Id == entryId) //This means that we are updating the same entry, so should allow same entryname
break;
switch(tryCount)
{
case 0:
newEntryName = entryName + wordSeparator + "Again";
break;
case 1:
newEntryName = entryName + wordSeparator + "Yet" + wordSeparator + "Again";
break;
case 2:
newEntryName = entryName + wordSeparator + "And" + wordSeparator + "Again";
break;
case 3:
newEntryName = entryName + wordSeparator + "Once" + wordSeparator + "More";
break;
case 4:
newEntryName = entryName + wordSeparator + "To" + wordSeparator + "Beat" + wordSeparator + "A" + wordSeparator +
"Dead" + wordSeparator + "Horse";
break;
}
if (tryCount++ > 5)
break; //Allow an exception to get thrown later.
newEntryName = FriendlyUrlSettings.TransformString(newEntryName, textTransform);
currentEntry = ObjectProvider.Instance().GetEntry(newEntryName, false, false);
}
return newEntryName;
}
public static string TransformString(string s, TextTransform textTransform)
{
switch (textTransform)
{
case TextTransform.None:
break;
case TextTransform.LowerCase:
return s.ToLower(CultureInfo.InvariantCulture);
case TextTransform.UpperCase:
return s.ToUpper(CultureInfo.InvariantCulture);
}
return s;
}
public static string Transform(this string str, TextTransform textTransform)
{
switch (textTransform)
{
case TextTransform.None:
return str;
case TextTransform.ToLower:
return str.ToLower();
case TextTransform.ToUpper:
return str.ToUpper();
case TextTransform.ToPascalNamingConvention:
return str.ToPascalNamingConvention();
case TextTransform.ToUnderscoreLowerCaseNamingConvention:
return str.ToUnderscoreLowerCaseNamingConvention();
case TextTransform.ToUnderscoreUpperCaseNamingConvention:
return str.ToUnderscoreUpperCaseNamingConvention();
default:
throw new NotImplementedException();
}
}
