public void TestUndoRedoCommand()
{
// Arrange
var project = new Project();
var context = new BlockCommandContext(project);
ProjectBlockCollection blocks = project.Blocks;
Block block = blocks[0];
using (block.AcquireBlockLock(RequestLock.Write))
{
block.SetText("abcd");
}
int blockVersion = block.Version;
BlockKey blockKey = block.BlockKey;
var command = new ReplaceTextCommand(
new BlockPosition(blockKey, 2), 1, "YES");
project.Commands.Do(command, context);
project.Commands.Undo(context);
// Act
project.Commands.Redo(context);
// Assert
Assert.AreEqual(1, blocks.Count);
Assert.AreEqual(
new BlockPosition(blocks[0], 5), project.Commands.LastPosition);
const int index = 0;
Assert.AreEqual("abYESd", blocks[index].Text);
Assert.AreEqual(blockVersion + 6, blocks[index].Version);
}
public void CanUndo_WithIndexGreaterThanZero_ShouldReturnTrue()
{
var history = new History();
var text = new Text();
var command = new ReplaceTextCommand(text, "text");
history.AddAndExecuteCommand(command);
Assert.IsTrue(history.CanUndo());
}
public void CanCreateCommandAndReplaceItemText()
{
var i = new TestReplacable();
i.Text = "test";
string str = "sth";
var c = new ReplaceTextCommand(i, str);
c.Execute();
Assert.AreEqual(i.Text, str);
}
public void Redo_WithValidIndex_ShouldRedoCommand()
{
var history = new History();
var text = new Text();
var command = new ReplaceTextCommand(text, "text");
history.AddAndExecuteCommand(command);
history.Undo();
Assert.IsTrue(history.CanRedo());
history.Redo();
}
public void Execute_ReplaceTextCommand_WithNewText_ShouldReplacePrevTextFromParagraph()
{
var paragraph = new Text()
{
Value = "Old text"
};
var newText = "New text";
var command = new ReplaceTextCommand(paragraph, newText);
command.Execute();
Assert.AreEqual(newText, paragraph.Value);
}
public void CanReturnTextBackToPreviousState()
{
var i = new TestReplacable();
string oldText = "test";
i.Text = oldText;
string str = "sth";
var c = new ReplaceTextCommand(i, str);
c.Execute();
Assert.AreEqual(i.Text, str);
c.Unexecute();
Assert.AreEqual(i.Text, oldText);
}
public void Execute_GetItemAndReplaceText()
{
// Arrange
var paragrpahDocumentItem = new DocumentItem(new Paragraph.Paragraph(""));
_documentMock.Setup(d => d.GetItem(It.IsAny <int>())).Returns(paragrpahDocumentItem);
ICommand command = new ReplaceTextCommand(1, "Hey", _documentMock.Object);
// Act
command.Execute();
// Assert
Assert.Equal("Hey", paragrpahDocumentItem.Paragraph.Text);
}
public void Unexecute_ReplaceTextCommand_ShouldReturnPrevTextToParagraph()
{
var prevText = "Old text";
var paragraph = new Text()
{
Value = prevText
};
var newText = "New text";
var command = new ReplaceTextCommand(paragraph, newText);
command.Execute();
Assert.AreEqual(newText, paragraph.Value);
command.Unexecute();
Assert.AreEqual(prevText, paragraph.Value);
}
/// <summary>
/// Gets the editor actions associated with the given TextSpan.
/// </summary>
/// <param name="block">The block.</param>
/// <param name="textSpan">The text span.</param>
/// <returns>
/// A list of editor actions associated with this span.
/// </returns>
/// <remarks>
/// This will be called within a read-only lock.
/// </remarks>
public IList <IEditorAction> GetEditorActions(
Block block,
TextSpan textSpan)
{
// We only get to this point if we have a misspelled word.
string word = textSpan.GetText(block.Text);
// Get the suggestions for the word.
IList <SpellingSuggestion> suggestions = GetSuggestions(word);
// Go through the suggestions and create an editor action for each one.
// These will already be ordered coming out of the GetSuggestions()
// method.
BlockCommandSupervisor commands = block.Project.Commands;
var actions = new List <IEditorAction>(suggestions.Count);
foreach (SpellingSuggestion suggestion in suggestions)
{
// Figure out the operation we'll be using to implement the change.
var command =
new ReplaceTextCommand(
new BlockPosition(block.BlockKey, textSpan.StartTextIndex),
textSpan.Length,
suggestion.Suggestion);
// Create the suggestion action, along with the replacement command.
var action =
new EditorAction(
string.Format("Change to \"{0}\"", suggestion.Suggestion),
new HierarchicalPath("/Plugins/Spelling/Change"),
context => commands.Do(command, context));
actions.Add(action);
}
// Add the additional editor actions from the plugins.
foreach (ISpellingProjectPlugin controller in SpellingControllers)
{
IEnumerable <IEditorAction> additionalActions =
controller.GetAdditionalEditorActions(word);
actions.AddRange(additionalActions);
}
// Return all the change actions.
return(actions);
}
public void AddAndExecuteCommand_WithElevenCommands_ShouldRemoveFirstCommand()
{
var history = new History();
var text = new Text();
var command = new ReplaceTextCommand(text, "text");
history.AddAndExecuteCommand(command);
history.AddAndExecuteCommand(command);
history.AddAndExecuteCommand(command);
history.AddAndExecuteCommand(command);
history.AddAndExecuteCommand(command);
history.AddAndExecuteCommand(command);
history.AddAndExecuteCommand(command);
history.AddAndExecuteCommand(command);
history.AddAndExecuteCommand(command);
history.AddAndExecuteCommand(command);
history.AddAndExecuteCommand(command);
}
public void ProcessImmediateEdits(
BlockCommandContext context,
Block block,
int textIndex)
{
// Get the plugin settings from the project.
ImmediateBlockTypesSettings settings = Settings;
// Grab the substring from the beginning to the index and compare that
// in the dictionary.
string text = block.Text.Substring(0, textIndex);
if (!settings.Replacements.ContainsKey(text))
{
// We want to fail as fast as possible.
return;
}
// If the block type is already set to the same name, skip it.
string blockTypeName = settings.Replacements[text];
BlockType blockType = Project.BlockTypes[blockTypeName];
if (block.BlockType == blockType)
{
return;
}
// Perform the substitution with a replace operation and a block change
// operation.
var replaceCommand =
new ReplaceTextCommand(
new BlockPosition(block.BlockKey, 0), textIndex, string.Empty);
var changeCommand = new ChangeBlockTypeCommand(block.BlockKey, blockType);
// Create a composite command that binds everything together.
var compositeCommand = new CompositeCommand <BlockCommandContext>(true, false);
compositeCommand.Commands.Add(replaceCommand);
compositeCommand.Commands.Add(changeCommand);
// Add the command to the deferred execution so the command could
// be properly handled via the undo/redo management.
block.Project.Commands.DeferDo(compositeCommand);
}
private void ReplaceTextCommandExecutor(string commandParams)
{
var argumentsParser = new ArgumentsParser(commandParams);
if (argumentsParser.NextArgumentsCount < 2)
{
throw new MenuException();
}
int?position = argumentsParser.GetNextAsInt();
if (position == null)
{
throw new MenuException();
}
string text = argumentsParser.GetNextsAsString(' ');
ICommand command = new ReplaceTextCommand(position.Value, text, _document);
command.Execute();
}
public void ReplacesText()
{
_engine = new AutomationEngineInstance(null);
_replaceTextCommand = new ReplaceTextCommand();
string inputText = "Hello john";
string oldSubstring = "Hello";
string newSubstring = "Goodbye";
VariableMethods.CreateTestVariable(inputText, _engine, "input", typeof(string));
VariableMethods.CreateTestVariable(oldSubstring, _engine, "old", typeof(string));
VariableMethods.CreateTestVariable(newSubstring, _engine, "new", typeof(string));
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(string));
_replaceTextCommand.v_InputText = "{input}";
_replaceTextCommand.v_OldText = "{old}";
_replaceTextCommand.v_NewText = "{new}";
_replaceTextCommand.v_OutputUserVariableName = "{output}";
_replaceTextCommand.RunCommand(_engine);
Assert.Equal("Goodbye john", "{output}".ConvertUserVariableToString(_engine));
}
static void Main(string[] args)
{
string command;
var path = "";
var param = "";
if (args.Length == 0)
{
Utils.PrintAvailableOperations();
Utils.Output("Enter operation name:", ConsoleColor.Yellow);
command = Console.ReadLine();
}
else
{
command = args[0];
if (args.Length > 1)
{
path = args[1];
}
if (args.Length > 2)
{
param = args[2];
}
}
command = command.Trim().Replace("/", "").Replace("-", "");
if (!CmdCommands.Exists(command))
{
Utils.OutputError("Incorrect operation");
Utils.PrintAvailableOperations();
return;
}
if (path.Length == 0)
{
path = Utils.RequestPath(command.Equals(CmdCommands.BrowseFolder) ? "Enter folder path:" : "Enter file name:", !command.Equals(CmdCommands.BrowseFolder));
if (path.Length == 0)
{
return;
}
}
CommonCommand cmd;
switch (command)
{
case CmdCommands.ReplaceText:
if (param.Length == 0)
{
Utils.Output("Enter word to replace:", ConsoleColor.Yellow);
param = Console.ReadLine();
}
cmd = new ReplaceTextCommand(path, param);
break;
case CmdCommands.CountWords:
cmd = new CountWordsCommand(path);
break;
case CmdCommands.ReverseWords:
cmd = new ReverseWordsCommand(path);
break;
case CmdCommands.BrowseFolder:
cmd = new BrowseFolderCommand(path);
break;
default:
cmd = new IncorrectCommand(path);
break;
}
cmd.DoWork();
}
public void ProcessImmediateEdits(
BlockCommandContext context,
Block block,
int textIndex)
{
// If we aren't optimized, we have to pull the settings back in from the
// project settings and optimize them.
if (!optimizedSubstitions)
{
RetrieveSettings();
}
// Pull out the edit text and add a leading space to simplify the
// "whole word" substitutions.
string editText = block.Text.Substring(0, textIndex);
if (editText.Length - 1 < 0)
{
return;
}
// Figure out if we're at a word break.
char finalCharacter = editText[editText.Length - 1];
bool isWordBreak = char.IsPunctuation(finalCharacter) ||
char.IsWhiteSpace(finalCharacter);
// Go through the substitution elements and look for each one.
foreach (RegisteredSubstitution substitution in Substitutions)
{
// If we are doing whole word searches, then we don't bother if
// the final character isn't a word break or if it isn't a word
// break before it.
ReplaceTextCommand command;
int searchLength = substitution.Search.Length;
int startSearchIndex = editText.Length - searchLength;
// If we are going to be searching before the string, then this
// search term will never be valid.
if (startSearchIndex < 0)
{
continue;
}
// Do the search based on the whole word or suffix search.
if (substitution.IsWholeWord)
{
// Check to see if we have a valid search term.
if (!isWordBreak)
{
continue;
}
if (startSearchIndex > 0 &&
char.IsPunctuation(editText[startSearchIndex - 1]))
{
continue;
}
if (startSearchIndex - 1 < 0)
{
continue;
}
// Make sure the string we're looking at actually is the same.
string editSubstring = editText.Substring(
startSearchIndex - 1, substitution.Search.Length);
if (editSubstring != substitution.Search)
{
// The words don't match.
continue;
}
// Perform the substitution with a replace operation.
command =
new ReplaceTextCommand(
new BlockPosition(block.BlockKey, startSearchIndex - 1),
searchLength + 1,
substitution.Replacement + finalCharacter);
}
else
{
// Perform a straight comparison search.
if (!editText.EndsWith(substitution.Search))
{
continue;
}
// Figure out the replace operation.
command =
new ReplaceTextCommand(
new BlockPosition(block.BlockKey, startSearchIndex),
searchLength,
substitution.Replacement);
}
// Add the command to the deferred execution so the command could
// be properly handled via the undo/redo management.
block.Project.Commands.DeferDo(command);
}
}
