public PrismicContext(prismic.Api.Api api, FSharpOption<string> maybeRef, FSharpOption<string> maybeAccessToken, prismic.Api.DocumentLinkResolver linkResolver)
{
this.api = api;
this.maybeRef = maybeRef;
this.maybeAccessToken = maybeAccessToken;
this.linkResolver = linkResolver;
}
private static async Task DoRequest()
{
Console.WriteLine(ApiQuery);
var storage = new FSharpOption<IStorageAsync>(new Storage.JsonFileStorage(@"..\..\client_secrets.json", @"..\..\stored_credentials.json"));
var httpclient = OAuth2Client.HttpClientFactory.WithOAuth2("query-api-1.0", storage, null, null);
var response = await httpclient.PostAsync(ApiEndpoint, new StringContent(ApiQuery));
if (response.StatusCode != HttpStatusCode.OK)
{
var errorBody = await response.Content.ReadAsStringAsync();
throw new Exception("Request failed:\n" + errorBody);
}
var jsonBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(jsonBody);
var resultSets = JArray.Parse(jsonBody);
var results =
from item in resultSets[0]
select new {Name = item["Name"], Estimate = item["Estimate"]}
;
foreach (var item in results)
{
Console.WriteLine("{0} {1}", item.Name, item.Estimate);
}
}
public static IEnumerable <T> AsEnumerable <T>(this FSharpOption <T> o) => o.IsSome() ? Enumerable.Repeat(o.Value, 1) : Enumerable.Empty <T>();
/// <summary>
/// Convert a LanguageExt OptionUnsafe into an F# Option
/// </summary>
public static FSharpOption <T> ToFSharp <T>(this OptionUnsafe <T> option) =>
matchUnsafe(option,
Some: v => FSharpOption <T> .Some(v),
None: () => FSharpOption <T> .None);
/// <summary>
/// Convert a F# Option into a LanguageExt Option
/// </summary>
public static Option <T> fs <T>(FSharpOption <T> fsOption) =>
FSharpOption <T> .get_IsSome(fsOption)
? Some(fsOption.Value)
: None;
int IOleCommandTarget.Exec(ref Guid commandGroup, uint commandId, uint commandExecOpt, IntPtr variantIn, IntPtr variantOut)
{
try
{
EditCommand editCommand;
if (TryConvert(commandGroup, commandId, variantIn, out editCommand))
{
if (editCommand.IsUndo)
{
_buffer.UndoRedoOperations.Undo(1);
return NativeMethods.S_OK;
}
else if (editCommand.IsRedo)
{
_buffer.UndoRedoOperations.Redo(1);
return NativeMethods.S_OK;
}
else if (editCommand.HasKeyInput)
{
var keyInput = editCommand.KeyInput;
// Swallow the input if it's been flagged by a previous QueryStatus
if (SwallowIfNextExecMatches.IsSome() && SwallowIfNextExecMatches.Value == keyInput)
{
return NativeMethods.S_OK;
}
var commandData = new OleCommandData(commandId, commandExecOpt, variantIn, variantOut);
if (TryExec(ref commandGroup, ref commandData, keyInput))
{
return NativeMethods.S_OK;
}
}
}
}
finally
{
SwallowIfNextExecMatches = FSharpOption<KeyInput>.None;
}
return _nextTarget.Exec(commandGroup, commandId, commandExecOpt, variantIn, variantOut);
}
private static string EntryToString( FSharpOption<Entry> entry )
{
return FSharpOption<Entry>.get_IsNone( entry )
? string.Empty
: entry.Value.Value.ToString( CultureInfo.InvariantCulture );
}
public Task <IDotNetCompilation> GetFunctionCompilationAsync(FunctionMetadata functionMetadata)
{
// First use the C# compiler to resolve references, to get consistency with the C# Azure Functions programming model
// Add the #r statements from the .fsx file to the resolver source
string scriptSource = GetFunctionSource(functionMetadata);
var resolverSourceBuilder = new StringBuilder();
using (StringReader sr = new StringReader(scriptSource))
{
string line;
while ((line = sr.ReadLine()) != null)
{
if (_hashRRegex.IsMatch(line))
{
resolverSourceBuilder.AppendLine(line);
}
}
}
resolverSourceBuilder.AppendLine("using System;");
var resolverSource = resolverSourceBuilder.ToString();
Script <object> script = CodeAnalysis.CSharp.Scripting.CSharpScript.Create(resolverSource, options: _metadataResolver.CreateScriptOptions(), assemblyLoader: AssemblyLoader.Value);
var compiler = new SimpleSourceCodeServices(msbuildEnabled: FSharpOption <bool> .Some(false));
FSharpErrorInfo[] errors = null;
FSharpOption <Assembly> assemblyOption = null;
string scriptPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(scriptPath);
string scriptFilePath = Path.Combine(scriptPath, Path.GetFileName(functionMetadata.ScriptFile));
var assemblyName = FunctionAssemblyLoader.GetAssemblyNameFromMetadata(functionMetadata, Guid.NewGuid().ToString());
var assemblyFileName = Path.Combine(scriptPath, assemblyName + ".dll");
var pdbName = Path.ChangeExtension(assemblyFileName, PlatformHelper.IsMono ? "dll.mdb" : "pdb");
try
{
var scriptFileBuilder = new StringBuilder();
// Write an adjusted version of the script file, prefixing some 'open' declarations
foreach (string import in script.Options.Imports)
{
scriptFileBuilder.AppendLine("open " + import);
}
// Suppress undesirable warnings
scriptFileBuilder.AppendLine("#nowarn \"988\"");
// Set the line to match the original script
scriptFileBuilder.AppendLine("# 0 @\"" + functionMetadata.ScriptFile + "\"");
// Add our original script
scriptFileBuilder.AppendLine(scriptSource);
File.WriteAllText(scriptFilePath, scriptFileBuilder.ToString());
var otherFlags = new List <string>();
otherFlags.Add("fsc.exe");
// The --noframework option is used because we will shortly add references to mscorlib and FSharp.Core
// as dictated by the C# reference resolver, and F# doesn't like getting multiple references to those.
otherFlags.Add("--noframework");
var references = script.GetCompilation().References
.Where(m => !(m is UnresolvedMetadataReference))
.Select(m => "-r:" + m.Display)
.Distinct(new FileNameEqualityComparer());
// Add the references as reported by the metadata resolver.
otherFlags.AddRange(references);
if (_optimizationLevel == OptimizationLevel.Debug)
{
otherFlags.Add("--optimize-");
otherFlags.Add("--debug+");
otherFlags.Add("--tailcalls-");
}
if (PlatformHelper.IsMono)
{
var monoDir = Path.GetDirectoryName(typeof(string).Assembly.Location);
var facadesDir = Path.Combine(monoDir, "Facades");
otherFlags.Add("--lib:" + facadesDir);
}
// If we have a private assembly folder, make sure the compiler uses it to resolve dependencies
string privateAssembliesFolder = Path.Combine(Path.GetDirectoryName(functionMetadata.ScriptFile), DotNetConstants.PrivateAssembliesFolderName);
if (Directory.Exists(privateAssembliesFolder))
{
otherFlags.Add("--lib:" + Path.Combine(Path.GetDirectoryName(functionMetadata.ScriptFile), DotNetConstants.PrivateAssembliesFolderName));
}
otherFlags.Add("--out:" + assemblyFileName);
// Get the #load closure
FSharpChecker checker = FSharpChecker.Create(null, null, null, msbuildEnabled: FSharpOption <bool> .Some(false));
var loadFileOptionsAsync = checker.GetProjectOptionsFromScript(functionMetadata.ScriptFile, scriptSource, null, null, null);
var loadFileOptions = FSharp.Control.FSharpAsync.RunSynchronously(loadFileOptionsAsync, null, null);
foreach (var loadedFileName in loadFileOptions.ProjectFileNames)
{
if (Path.GetFileName(loadedFileName) != Path.GetFileName(functionMetadata.ScriptFile))
{
otherFlags.Add(loadedFileName);
}
}
// Add the (adjusted) script file itself
otherFlags.Add(scriptFilePath);
// Compile the script to a static assembly
var result = compiler.Compile(otherFlags.ToArray());
errors = result.Item1;
var code = result.Item2;
if (code == 0)
{
var assemblyBytes = File.ReadAllBytes(assemblyFileName);
byte[] pdbBytes = null;
if (File.Exists(pdbName))
{
pdbBytes = File.ReadAllBytes(pdbName);
}
var assembly = Assembly.Load(assemblyBytes, pdbBytes);
assemblyOption = FSharpOption <Assembly> .Some(assembly);
}
else
{
string message = $"F# compilation failed with arguments: {string.Join(" ", otherFlags)}";
_traceWriter.Verbose(message);
_logger?.LogDebug(message);
}
}
finally
{
DeleteDirectoryAsync(scriptPath, recursive: true)
.ContinueWith(
t => t.Exception.Handle(e =>
{
string message = $"Unable to delete F# compilation file: {e.ToString()}";
_traceWriter.Warning(message);
_logger?.LogWarning(message);
return(true);
}), TaskContinuationOptions.OnlyOnFaulted);
}
return(Task.FromResult <IDotNetCompilation>(new FSharpCompilation(errors, assemblyOption)));
}
public static bool IsNone <T>(this FSharpOption <T> option)
{
return(FSharpOption <T> .get_IsNone(option));
}
public int UpdateTerrainCubes(TerrainModel terrain, FSharpOption<TerrainModel> old)
{
HashSet<ClientConnection> newClients;
int newCube = WorldModel.GetCubeKey(terrain.Position);
if (!CubeClients.TryGetValue(newCube, out newClients))
newClients = new HashSet<ClientConnection>();
if (old != null)
{
int oldCube = WorldModel.GetCubeKey(old.Value.Position);
HashSet<ClientConnection> oldClients;
if (!CubeClients.TryGetValue(oldCube, out oldClients))
oldClients = new HashSet<ClientConnection>();
if (oldCube != newCube)
foreach (var c in oldClients.Except(newClients))
c.Drop(terrain);
}
foreach (var c in newClients)
c.Send(terrain);
return newCube;
}
public int UpdateEntityCubes(EntityModel entity, FSharpOption<EntityModel> old)
{
int newCube = WorldModel.GetCubeKey(entity.Position);
// update client cubes if the entity was possessed
ClientConnection client;
if (Possession.TryGetValue(entity.Id, out client)) {
var newCubes = new HashSet<int>(WorldModel.GetNearbyCubeKeys(newCube));
HashSet<int> oldCubes;
HashSet<ClientConnection> clients;
IEnumerable<int> add;
if (ClientCubes.TryGetValue(client, out oldCubes))
{
foreach (var cube in oldCubes.Except(newCubes))
{
if (CubeClients.TryGetValue(cube, out clients))
{
clients.Remove(client);
if (clients.Count == 0)
CubeClients.Remove(cube);
}
}
add = newCubes.Except(oldCubes);
}
else
add = newCubes;
foreach (var cube in add)
if (CubeClients.TryGetValue(cube, out clients))
clients.Add(client);
else
CubeClients.Add(cube, new HashSet<ClientConnection> { client });
ClientCubes[client] = newCubes;
}
// notify all clients subscribed to the relevant cubes
HashSet<ClientConnection> newClients;
if (!CubeClients.TryGetValue(newCube, out newClients))
newClients = new HashSet<ClientConnection>();
if (old != null)
{
int oldCube = WorldModel.GetCubeKey(old.Value.Position);
HashSet<ClientConnection> oldClients;
if (!CubeClients.TryGetValue(oldCube, out oldClients))
oldClients = new HashSet<ClientConnection>();
if (oldCube != newCube)
foreach (var c in oldClients.Except(newClients))
c.Drop(entity);
}
foreach (var c in newClients.Where(x => x != client))
c.Send(entity);
return newCube;
}
public void Start()
{
Double distanceTheta = 1.0, shavingTheta = 0.99, shavingAlpha = 0.2;
int phevLearningWindow = 40, nDays = 10;
Int32.TryParse(textBoxPhevLearning.Text, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out phevLearningWindow);
Int32.TryParse(textBoxDays.Text, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out nDays);
Double.TryParse(textBoxDistanceTheta.Text, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out distanceTheta);
Double.TryParse(textBoxShavingAlpha.Text, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out shavingAlpha);
Double.TryParse(textBoxShavingTheta.Text, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out shavingTheta);
button1.Enabled = false;
FSharpOption<Sim.Method> method = null;
FSharpOption<Sim.Contribution> contr = null;
FSharpOption<Sim.Scheduler> scheduler = null;
started = DateTime.Now;
updateLog("-------------------------------------");
String dayah = "", mech = "", phev = "";
switch (comboBox1.SelectedItem.ToString())
{
case "Peak-shaving":
dayah = String.Format("Centralized (peak-shaving): alpha={0}, theta={1}", shavingAlpha, shavingTheta);
method = new FSharpOption<Sim.Method>(Sim.Method.Shaving);
break;
case "Distance-rule":
dayah = String.Format("Centralized (distance-rule): theta={0}", distanceTheta);
method = new FSharpOption<Sim.Method>(Sim.Method.Distance);
break;
case "Superposition":
method = new FSharpOption<Sim.Method>(Sim.Method.Superposition);
break;
case "Random":
dayah = (String.Format("Decentralized (Random)"));
method = new FSharpOption<Sim.Method>(Sim.Method.Random);
break;
case "Mixed":
dayah = (String.Format("Decentralized (Mixed)"));
method = new FSharpOption<Sim.Method>(Sim.Method.Mixed);
break;
case "None":
method = FSharpOption<Sim.Method>.None;
break;
}
updateLog(String.Format("Dayahead:\t {0}", dayah));
switch (comboBox2.SelectedItem.ToString())
{
case "Proactive":
mech = "Proactive";
scheduler = new FSharpOption<Sim.Scheduler>(Sim.Scheduler.Proactive);
break;
case "Reactive":
mech = "Reactive";
scheduler = new FSharpOption<Sim.Scheduler>(Sim.Scheduler.Reactive);
break;
case "Random":
mech = "Random";
scheduler = new FSharpOption<Sim.Scheduler>(Sim.Scheduler.Random);
break;
case "Mixed":
mech = "Mixed";
scheduler = new FSharpOption<Sim.Scheduler>(Sim.Scheduler.Mixed);
break;
case "None":
mech = "None";
scheduler = FSharpOption<Sim.Scheduler>.None;
break;
}
updateLog(String.Format("Mechanism:\t {0}", mech));
switch (comboBox3.SelectedItem.ToString())
{
case "Expected":
phev = "Expected";
contr = new FSharpOption<Sim.Contribution>(Sim.Contribution.Expected);
break;
case "Simulated":
phev = "Simulated";
contr = new FSharpOption<Sim.Contribution>(Sim.Contribution.Simulated);
break;
case "None":
phev = "None";
contr = FSharpOption<Sim.Contribution>.None;
break;
}
updateLog(String.Format("Contribution:\t {0}", phev));
updateLog(String.Format("Window (PHEV):\t {0}", phevLearningWindow));
updateLog(String.Format("Days:\t\t {0}", nDays));
updateLog("-------------------------------------");
tSim.PhevWindow = phevLearningWindow;
tSim.Scheduler = scheduler;
tSim.DistanceTheta = distanceTheta;
tSim.ShavingAlpha = shavingAlpha;
tSim.ShavingTheta = shavingTheta;
tSim.Method = method;
tSim.Contribution = contr;
tSim.Days = nDays;
progressBar1.Minimum = 0;
BackgroundWorker bgWorker;
bgWorker = new BackgroundWorker();
bgWorker.DoWork += new DoWorkEventHandler(Simulation_Start);
bgWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(Simulation_Completed);
bgWorker.RunWorkerAsync(tSim);
}
public Task<prismic.Api.Api> Get(FSharpOption<string> accessToken)
{
return prismic.extensions.Api.Get (accessToken, this.apiUrl, cache, this.logger);
}
public BackRefEventArgs(FSharpOption<ICSharpLiteralExpression> br)
{
BackRef = br;
}
public static bool IsSome <T>(this FSharpOption <T> o) => FSharpOption <T> .get_IsSome(o);
public static FSharpOption <TR> Bind <T, TR>(this FSharpOption <T> option, Func <T, FSharpOption <TR> > f)
{
return(option.IsNone() ? FSharpOption <TR> .None : f(option.Value));
}
public FSharpCompilation(FSharpErrorInfo[] errors, FSharpOption<Assembly> assemblyOption)
{
_errors = errors;
_assemblyOption = assemblyOption;
}
internal static MotionData CreateMotionData(
Motion motion,
int count)
{
return(CreateMotionData(motion, new MotionArgument(MotionContext.AfterOperator, FSharpOption.Create(count), FSharpOption <int> .None)));
}
private static string BuildXUnit2Args(FSharpOption<Tuple<string, string>> includeTrait, FSharpOption<Tuple<string, string>> excludeTrait)
{
var parameters = new XUnit2Helper.XUnit2Params("", "", XUnit2Helper.ParallelOption.None, 0, false, false,
true, false, false,null, TimeSpan.FromMinutes(5), UnitTestCommon.TestRunnerErrorLevel.Error, includeTrait, excludeTrait, false, false, true, "");
return XUnit2Helper.buildXUnit2Args(parameters, "test.dll");
}
/// <summary>
/// Converts <see cref="FSharpOption{T}"/> to <see cref="Nullable"/>.
/// </summary>
private static T?AsNullable <T>(this FSharpOption <T> opt) where T : struct
{
return(FSharpOption <T> .get_IsNone(opt) ? new T?() : opt.Value);
}
public static Dictionary<AST.Address, string> StoreOutputs(AST.Address[] outputs, DAG dag)
{
// output dict
var d = new Dictionary<AST.Address, string>();
// partition all of the output addresses by their worksheet
var addr_groups = outputs.GroupBy(addr => dag.getCOMRefForAddress(addr).WorksheetName);
// for each worksheet, do an array read of the formulas
foreach (IEnumerable<AST.Address> ws_fns in addr_groups)
{
// get worksheet used range
var fstcr = dag.getCOMRefForAddress(ws_fns.First());
var rng = fstcr.Worksheet.UsedRange;
// get used range dimensions
var left = rng.Column;
var right = rng.Columns.Count + left - 1;
var top = rng.Row;
var bottom = rng.Rows.Count + top - 1;
// get names
var wsname = new FSharpOption<string>(fstcr.WorksheetName);
var wbname = new FSharpOption<string>(fstcr.WorkbookName);
var path = fstcr.Path;
// sometimes the used range is a range
if (left != right || top != bottom)
{
// y is the first index
// x is the second index
object[,] data = rng.Value2; // fast array read
var x_del = left - 1;
var y_del = top - 1;
foreach (AST.Address addr in ws_fns)
{
// construct address in formulas array
var x = addr.X - x_del;
var y = addr.Y - y_del;
// get string
String s = System.Convert.ToString(data[y, x]);
if (String.IsNullOrWhiteSpace(s))
{
d.Add(addr, "");
}
else
{
d.Add(addr, s);
}
}
}
// and other times it is a single cell
else
{
// construct the appropriate AST.Address
AST.Address addr = AST.Address.NewFromR1C1(top, left, wsname, wbname, path);
// make certain that it is actually a string
String s = System.Convert.ToString(rng.Value2);
// add to dictionary, as appropriate
if (String.IsNullOrWhiteSpace(s))
{
d.Add(addr, "");
}
else
{
d.Add(addr, s);
}
}
}
return d;
}
protected void RaiseActiveTextViewChanged(FSharpOption<ITextView> oldTextView, FSharpOption<ITextView> newTextView)
{
if (_activeTextViewChanged != null)
{
var args = new TextViewChangedEventArgs(oldTextView, newTextView);
_activeTextViewChanged(this, args);
}
}
int IOleCommandTarget.Exec(ref Guid commandGroup, uint commandId, uint commandExecOpt, IntPtr variantIn, IntPtr variantOut)
{
try
{
EditCommand editCommand;
if (TryConvert(commandGroup, commandId, variantIn, out editCommand))
{
if (editCommand.IsUndo)
{
// The user hit the undo button. Don't attempt to map anything here and instead just
// run a single Vim undo operation
_buffer.UndoRedoOperations.Undo(1);
return NativeMethods.S_OK;
}
else if (editCommand.IsRedo)
{
// The user hit the redo button. Don't attempt to map anything here and instead just
// run a single Vim redo operation
_buffer.UndoRedoOperations.Redo(1);
return NativeMethods.S_OK;
}
else if (editCommand.HasKeyInput)
{
var keyInput = editCommand.KeyInput;
// Swallow the input if it's been flagged by a previous QueryStatus
if (SwallowIfNextExecMatches.IsSome() && SwallowIfNextExecMatches.Value == keyInput)
{
return NativeMethods.S_OK;
}
// Try and process the command with the IVimBuffer
var commandData = new OleCommandData(commandId, commandExecOpt, variantIn, variantOut);
if (TryProcessWithBuffer(ref commandGroup, ref commandData, keyInput))
{
return NativeMethods.S_OK;
}
}
}
}
finally
{
SwallowIfNextExecMatches = FSharpOption<KeyInput>.None;
}
return _nextTarget.Exec(commandGroup, commandId, commandExecOpt, variantIn, variantOut);
}
protected void AssertPosition(int lineNumber, int column, FSharpOption<VirtualSnapshotPoint> option)
{
Assert.True(option.IsSome());
var line = VirtualSnapshotPointUtil.GetPoint(option.value).GetColumn();
Assert.Equal(lineNumber, line.LineNumber);
Assert.Equal(column, line.Column);
}
/// <summary>
/// With Resharper installed we need to special certain keys like Escape. They need to
/// process it in order for them to dismiss their custom intellisense but their processing
/// will swallow the event and not propagate it to us. So handle, return and account
/// for the double stroke in exec
/// </summary>
private CommandAction? QueryStatusInResharper(KeyInput keyInput)
{
CommandAction? action = null;
if (_buffer.ModeKind == ModeKind.Insert && keyInput == KeyInputUtil.EscapeKey)
{
// Have to special case Escape here for insert mode. R# is typically ahead of us on the IOleCommandTarget
// chain. If a completion window is open and we wait for Exec to run R# will be ahead of us and run
// their Exec call. This will lead to them closing the completion window and not calling back into
// our exec leaving us in insert mode.
action = CommandAction.Enable;
}
else if (_buffer.ModeKind == ModeKind.ExternalEdit && keyInput == KeyInputUtil.EscapeKey)
{
// Have to special case Escape here for external edit mode because we want escape to get us back to
// normal mode
action = CommandAction.Enable;
}
else if (_adapter.InDebugMode && (keyInput == KeyInputUtil.EnterKey || keyInput.Key == VimKey.Back))
{
// In debug mode R# will intercept Enter and Back
action = CommandAction.Enable;
}
else if (keyInput == KeyInputUtil.EnterKey && _buffer.ModeKind != ModeKind.Insert && _buffer.ModeKind != ModeKind.Replace)
{
// R# will intercept the Enter key when we are in the middle of an XML doc comment presumable
// to do some custom formatting. If we're not insert mode we need to handle that here and
// suppress the command to keep them from running it
action = CommandAction.Disable;
}
// Only process the KeyInput if we are enabling the value. When the value is Enabled
// we return Enabled from QueryStatus and Visual Studio will push the KeyInput back
// through the event chain where either of the following will happen
//
// 1. R# will handle the KeyInput
// 2. R# will not handle it, it will get back to us and we will ignore it
//
// If the command is disabled though it will not go through IOleCommandTarget and instead will end
// up in the KeyProcessor code which will handle the value
if (action.HasValue && action.Value == CommandAction.Enable && _buffer.Process(keyInput).IsAnyHandled)
{
SwallowIfNextExecMatches = FSharpOption.Create(keyInput);
}
return action;
}
/// <summary>
/// Convert a LanguageExt Option into an F# Option
/// </summary>
public static FSharpOption <T> ToFSharp <T>(this Option <T> option) =>
option.IsNone
? FSharpOption <T> .None
: match(option,
Some: v => FSharpOption <T> .Some(v),
None: () => failwith <FSharpOption <T> >("returns null, so can't use the None branch"));
public void SerializationTests_FSharp_IntOption_Some()
{
RoundtripSerializationTest(FSharpOption <int> .Some(10));
}
public static bool IsSomeValue <T>(this FSharpOption <T> o, T value) => o.IsSome() && o.Value.Equals(value);
public abstract FSharpOption <ListItem> NavigateToListItem(ListKind listKind, NavigationKind navigationKind, FSharpOption <int> argument, bool hasBang);
public static T GetOr <T>(this FSharpOption <T> o, T ifNone) => o.IsSome() ? o.Value : ifNone;
public Microsoft.FSharp.Core.FSharpOption <ITextView> GetFocusedTextView()
{
return(FSharpOption.CreateForReference(FocusedTextView));
}
public static T ValueOrDefault <T>(this FSharpOption <T> option, T defaultValue)
{
return(option.IsNone() ? defaultValue : option.Value);
}
public Instance Create()
{
var completed = WebSharper.UI.Templating.Runtime.Server.Handler.CompleteHoles(key, holes, new Tuple <string, WebSharper.UI.Templating.Runtime.Server.ValTy>[] { Tuple.Create("name", WebSharper.UI.Templating.Runtime.Server.ValTy.String) });
var doc = WebSharper.UI.Templating.Runtime.Server.Runtime.GetOrLoadTemplate("index", FSharpOption <string> .Some("main"), FSharpOption <string> .Some("index.html"), "\r\n <ul ws-hole=\"ListContainer\">\r\n <li ws-template=\"ListItem\">${Name}</li>\r\n </ul>\r\n <div>\r\n <input ws-var=\"Name\" placeholder=\"Name\">\r\n <button ws-onclick=\"Add\">Add</button>\r\n <div>You are about to add: ${Name}</div>\r\n </div>\r\n ", completed.Item1, FSharpOption <string> .Some("index"), ServerLoad.WhenChanged, new Tuple <string, FSharpOption <string>, string>[] { }, false);
instance = new Instance(completed.Item2, doc);
return(instance);
}
public static FSharpOption <TR> Map <T, TR>(this FSharpOption <T> option, Func <T, TR> f)
{
return(option.IsNone() ? FSharpOption <TR> .None : FSharpOption <TR> .Some(f(option.Value)));
}
public Instance Create()
{
var completed = WebSharper.UI.Templating.Runtime.Server.Handler.CompleteHoles(key, holes, new Tuple <string, WebSharper.UI.Templating.Runtime.Server.ValTy>[] { });
var doc = WebSharper.UI.Templating.Runtime.Server.Runtime.GetOrLoadTemplate("index", null, FSharpOption <string> .Some("index.html"), "<!DOCTYPE html>\r\n<html lang=\"en\">\r\n<head>\r\n <title>$safeprojectname$</title>\r\n <meta charset=\"utf-8\">\r\n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\r\n <link rel=\"stylesheet\" type=\"text/css\" href=\"Content/$safeprojectname$.css\">\r\n <style>\r\n /* Don't show the not-yet-loaded templates */\r\n [ws-template], [ws-children-template] {\r\n display: none;\r\n }\r\n </style>\r\n <script type=\"text/javascript\" src=\"Content/$safeprojectname$.head.js\"></script>\r\n</head>\r\n<body>\r\n <h1>My list of unique people</h1>\r\n <div id=\"main\" ws-children-template=\"Main\">\r\n <ul ws-hole=\"ListContainer\">\r\n <li ws-template=\"ListItem\">${Name}</li>\r\n </ul>\r\n <div>\r\n <input ws-var=\"Name\" placeholder=\"Name\">\r\n <button ws-onclick=\"Add\">Add</button>\r\n <div>You are about to add: ${Name}</div>\r\n </div>\r\n </div>\r\n <script type=\"text/javascript\" src=\"Content/$safeprojectname$.min.js\"></script>\r\n</body>\r\n</html>\r\n", completed.Item1, FSharpOption <string> .Some("index"), ServerLoad.WhenChanged, new Tuple <string, FSharpOption <string>, string>[] { }, false);
instance = new Instance(completed.Item2, doc);
return(instance);
}
internal static Tuple <IIndex <a>, VectorConstruction> restrictToRowIndex <a>(Lookup lookup, IIndex <a> restriction, IIndex <a> sourceIndex, VectorConstruction vector)
{
if ((((lookup != Lookup.Exact ? 0 : (restriction.IsOrdered ? 1 : 0)) == 0 ? 0 : (sourceIndex.IsOrdered ? 1 : 0)) == 0 ? 0 : (!restriction.IsEmpty ? 1 : 0)) == 0)
{
return(new Tuple <IIndex <a>, VectorConstruction>(sourceIndex, vector));
}
Tuple <a, a> keyRange = restriction.KeyRange;
a a1 = keyRange.Item1;
a a2 = keyRange.Item2;
return(sourceIndex.Builder.GetRange <a>(new Tuple <IIndex <a>, VectorConstruction>(sourceIndex, vector), new Tuple <FSharpOption <Tuple <a, BoundaryBehavior> >, FSharpOption <Tuple <a, BoundaryBehavior> > >(FSharpOption <Tuple <a, BoundaryBehavior> > .Some(new Tuple <a, BoundaryBehavior>(a1, BoundaryBehavior.get_Inclusive())), FSharpOption <Tuple <a, BoundaryBehavior> > .Some(new Tuple <a, BoundaryBehavior>(a2, BoundaryBehavior.get_Inclusive())))));
}
public Instance Create()
{
var completed = WebSharper.UI.Templating.Runtime.Server.Handler.CompleteHoles(key, holes, new Tuple <string, WebSharper.UI.Templating.Runtime.Server.ValTy>[] { });
var doc = WebSharper.UI.Templating.Runtime.Server.Runtime.GetOrLoadTemplate("index", FSharpOption <string> .Some("listitem"), FSharpOption <string> .Some("index.html"), "<li>${Name}</li>", completed.Item1, FSharpOption <string> .Some("index"), ServerLoad.WhenChanged, new Tuple <string, FSharpOption <string>, string>[] { }, true);
instance = new Instance(completed.Item2, doc);
return(instance);
}
internal static BindData <T> CreateBindData <T>(Func <KeyInput, BindResult <T> > func = null, KeyRemapMode remapMode = null)
{
func = func ?? (x => BindResult <T> .Cancelled);
return(new BindData <T>(FSharpOption.CreateForReference(remapMode), func.ToFSharpFunc()));
}
public FSharpOption <ITextView> GetFocusedTextView()
{
var doc = IdeServices.DocumentManager.ActiveDocument;
return(FSharpOption.CreateForReference(TextViewFromDocument(doc)));
}
public static FSharpOption <T> Some <T>(T obj)
{
return(FSharpOption <T> .Some(obj));
}
public FSharpOption <ITextView> LoadFileIntoNewWindow(string filePath, FSharpOption <int> line, FSharpOption <int> column)
{
if (File.Exists(filePath))
{
var document = IdeApp.Workbench.OpenDocument(filePath, null, line.SomeOrDefault(0), column.SomeOrDefault(0)).Result;
var textView = TextViewFromDocument(document);
return(FSharpOption.CreateForReference(textView));
}
return(FSharpOption <ITextView> .None);
}
public static FSharpOption <T> ToFsOption <T>(Option <T> option) =>
option.Match(() => FSharpOption <T> .None,
v => FSharpOption <T> .Some(v));
public FSharpOption <ListItem> NavigateToListItem(ListKind listKind, NavigationKind navigationKind, FSharpOption <int> argumentOption, bool hasBang)
{
if (listKind == ListKind.Error)
{
var errors = IdeServices.TaskService.Errors;
if (errors.Count > 0)
{
var argument = argumentOption.IsSome() ? new int?(argumentOption.Value) : null;
var currentIndex = errors.CurrentLocationTask == null ? -1 : errors.IndexOf(errors.CurrentLocationTask);
var index = GetListItemIndex(navigationKind, argument, currentIndex, errors.Count);
if (index.HasValue)
{
var errorItem = errors.ElementAt(index.Value);
errors.CurrentLocationTask = errorItem;
errorItem.SelectInPad();
errorItem.JumpToPosition();
// Item number is one-based.
var listItem = new ListItem(index.Value + 1, errors.Count, errorItem.Message);
return(FSharpOption.CreateForReference(listItem));
}
}
}
return(FSharpOption <ListItem> .None);
}
public void Create(bool haveRealTransaction = true)
{
_factory = new MockRepository(MockBehavior.Strict);
_editorOperations = _factory.Create <IEditorOperations>();
if (haveRealTransaction)
{
_realTransaction = _factory.Create <ITextUndoTransaction>();
_transactionRaw = new UndoTransaction(FSharpOption.Create(_realTransaction.Object), FSharpOption.Create(_editorOperations.Object));
}
else
{
_transactionRaw = new UndoTransaction(FSharpOption <ITextUndoTransaction> .None, FSharpOption <IEditorOperations> .None);
}
_transaction = _transactionRaw;
}
/// <summary>
/// With Resharper installed we need to special certain keys like Escape. They need to
/// process it in order for them to dismiss their custom intellisense but their processing
/// will swallow the event and not propagate it to us. So handle, return and account
/// for the double stroke in exec
/// </summary>
private CommandStatus?QueryStatusInResharper(KeyInput keyInput)
{
CommandStatus?status = null;
var passToResharper = true;
if (_buffer.ModeKind.IsAnyInsert() && keyInput == KeyInputUtil.EscapeKey)
{
// Have to special case Escape here for insert mode. R# is typically ahead of us on the IOleCommandTarget
// chain. If a completion window is open and we wait for Exec to run R# will be ahead of us and run
// their Exec call. This will lead to them closing the completion window and not calling back into
// our exec leaving us in insert mode.
status = CommandStatus.Enable;
}
else if (_buffer.ModeKind == ModeKind.ExternalEdit && keyInput == KeyInputUtil.EscapeKey)
{
// Have to special case Escape here for external edit mode because we want escape to get us back to
// normal mode. However we do want this key to make it to R# as well since they may need to dismiss
// intellisense
status = CommandStatus.Enable;
}
else if ((keyInput.Key == VimKey.Back || keyInput == KeyInputUtil.EnterKey) && _buffer.ModeKind != ModeKind.Insert)
{
// R# special cases both the Back and Enter command in various scenarios
//
// - Enter is special cased in XML doc comments presumably to do custom formatting
// - Enter is supressed during debugging in Exec. Presumably this is done to avoid the annoying
// "Invalid ENC Edit" dialog during debugging.
// - Back is special cased to delete matched parens in Exec.
//
// In all of these scenarios if the Enter or Back key is registered as a valid Vim
// command we want to process it as such and prevent R# from seeing the command. If
// R# is allowed to see the command they will process it often resulting in double
// actions
status = CommandStatus.Enable;
passToResharper = false;
}
// Only process the KeyInput if we are enabling the value. When the value is Enabled
// we return Enabled from QueryStatus and Visual Studio will push the KeyInput back
// through the event chain where either of the following will happen
//
// 1. R# will handle the KeyInput
// 2. R# will not handle it, it will come back to use in Exec and we will ignore it
// because we mark it as silently handled
if (status.HasValue && status.Value == CommandStatus.Enable && _buffer.Process(keyInput).IsAnyHandled)
{
// We've broken the rules a bit by handling the command in QueryStatus and we need
// to silently handle this command if it comes back to us again either through
// Exec or through the VsKeyProcessor
_bufferCoordinator.DiscardedKeyInput = FSharpOption.Create(keyInput);
// If we need to cooperate with R# to handle this command go ahead and pass it on
// to them. Else mark it as Disabled.
//
// Marking it as Disabled will cause the QueryStatus call to fail. This means the
// KeyInput will be routed to the KeyProcessor chain for the ITextView eventually
// making it to our VsKeyProcessor. That component respects the SilentlyHandled
// statu of KeyInput and will siently handle it
status = passToResharper ? CommandStatus.Enable : CommandStatus.Disable;
}
return(status);
}
private static string BuildXUnitArgs(FSharpOption<Tuple<string, string>> includeTrait, FSharpOption<Tuple<string, string>> excludeTrait)
{
return XUnitHelper.buildXUnitArgs(new XUnitHelper.XUnitParams("","",false,false,false,"",false,false,TimeSpan.MinValue,"",UnitTestCommon.TestRunnerErrorLevel.Error,includeTrait,excludeTrait), "test.dll");
}
private static FSharpOption <MotionResult> CreateMotionResultSome()
{
return(FSharpOption.Create(CreateMotionResult()));
}
/// <summary>
/// With Resharper installed we need to special certain keys like Escape. They need to
/// process it in order for them to dismiss their custom intellisense but their processing
/// will swallow the event and not propagate it to us. So handle, return and account
/// for the double stroke in exec
/// </summary>
private CommandAction? QueryStatusInResharper(KeyInput keyInput)
{
CommandAction? action = null;
if (_buffer.ModeKind == ModeKind.Insert && keyInput == KeyInputUtil.EscapeKey)
{
// Have to special case Escape here for insert mode. R# is typically ahead of us on the IOleCommandTarget
// chain. If a completion window is open and we wait for Exec to run R# will be ahead of us and run
// their Exec call. This will lead to them closing the completion window and not calling back into
// our exec leaving us in insert mode.
action = CommandAction.Enable;
}
else if (_buffer.ModeKind == ModeKind.ExternalEdit && keyInput == KeyInputUtil.EscapeKey)
{
// Have to special case Escape here for external edit mode because we want escape to get us back to
// normal mode
action = CommandAction.Enable;
}
else if (_adapter.InDebugMode && (keyInput == KeyInputUtil.EnterKey || keyInput.Key == VimKey.Back))
{
// In debug mode R# will intercept Enter and Back
action = CommandAction.Enable;
}
else if (keyInput == KeyInputUtil.EnterKey && _buffer.ModeKind != ModeKind.Insert && _buffer.ModeKind != ModeKind.Replace)
{
// R# will intercept the Enter key when we are in the middle of an XML doc comment presumable
// to do some custom formatting. If we're not insert mode we need to handle that here and
// suppress the command to keep them from running it
action = CommandAction.Disable;
}
if (action.HasValue && _buffer.Process(keyInput))
{
SwallowIfNextExecMatches = FSharpOption.Create(keyInput);
}
return action;
}
internal static Command CreateLongCommand(string name, Func<KeyInput, bool> func, FSharpOption<KeyRemapMode> keyRemapModeOption = null, CommandFlags flags = CommandFlags.None)
{
return CreateLongCommand(
name,
(x, y) =>
{
FSharpFunc<KeyInput, LongCommandResult> realFunc = null;
Converter<KeyInput, LongCommandResult> func2 = ki =>
{
if (func(ki))
{
return LongCommandResult.NewFinished(CommandResult.NewCompleted(ModeSwitch.NoSwitch));
}
else
{
return LongCommandResult.NewNeedMoreInput(keyRemapModeOption, realFunc);
}
};
realFunc = func2;
return LongCommandResult.NewNeedMoreInput(keyRemapModeOption, realFunc);
},
flags);
}
