public Interpreters(string token) { Logger.Write("Initializing interpreters"); _token = token; var reader = new ConfigReader(_token); readInterpreters(reader); }
private static void setupLogging(string path) { var reader = new ConfigReader(path); var logPath = reader.Get("oi.logpath"); if (Directory.Exists(logPath)) Logger.Assign(new FileLogger(Path.Combine(logPath, "OpenIDE.CodeEngine.log"))); }
public static void Main(string[] args) { if (args.Length < 1) return; var path = args[0]; setupLogging(path); Logger.Write("Initializing with path: {0}", path); string defaultLanguage = null; if (args.Length > 1) { defaultLanguage = args[1]; Logger.Write("Default language is: {0}", defaultLanguage); } string[] enabledLanguages = null; if (args.Length > 2 && args[2].Length > 0) { enabledLanguages = args[2].Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries); Logger.Write("Enabled languages are: {0}", args[2]); } if (!Directory.Exists(path) && !File.Exists(path)) return; var endpoint = Bootstrapper.GetEndpoint(path, enabledLanguages); var reader = new ConfigReader(path); var fallbackmode = reader.Get("oi.fallbackmode") != "disabled"; if (fallbackmode) { Logger.Write("Starting code engine with fallback mode"); if (!runForm(endpoint, defaultLanguage)) startEngine(endpoint); } else { Logger.Write("Starting code engine"); startEngineNoX(endpoint); } Bootstrapper.Shutdown(); }
private void readInterpreters(ConfigReader config) { var prefix = "interpreter."; foreach (var interpreter in config.GetStartingWith(prefix)) { if (interpreter.Key.Length <= prefix.Length) continue; var extension = interpreter.Key .Substring( prefix.Length, interpreter.Key.Length - prefix.Length); if (extension.Length == 0) continue; extension = "." + extension; var path = interpreter.Value; if (Environment.OSVersion.Platform != PlatformID.Unix && Environment.OSVersion.Platform != PlatformID.MacOSX) { path.Replace("/", "\\"); } if (!File.Exists(path)) { var modifiedPath = System.IO.Path.Combine( System.IO.Path.GetDirectoryName( Assembly.GetExecutingAssembly().Location), path); if (File.Exists(path)) path = modifiedPath; } if (!_interpreters.ContainsKey(extension)) { Logger.Write("Adding interpreter: " + path + " for " + extension); _interpreters.Add(extension, path); } } }
public AppSettings(string path, Func<IEnumerable<ICommandHandler>> handlers, Func<IEnumerable<ICommandHandler>> pluginHandlers) { _path = path; SourcePrioritization = new string[] {}; var locator = new ProfileLocator(fixPath(Environment.CurrentDirectory)); RootPath = locator.GetLocalProfilePath("default"); if (RootPath == null) RootPath = fixPath(Directory.GetCurrentDirectory()); else RootPath = System.IO.Path.GetDirectoryName(RootPath); var reader = new ConfigReader(RootPath); var defaultLanguage = reader.Get("default.language"); if (defaultLanguage != null) DefaultLanguage = defaultLanguage; var enabledLanguages = reader.Get("enabled.languages"); if (enabledLanguages != null) EnabledLanguages = splitValue(enabledLanguages); var prioritizedSources = reader.Get("oi.source.prioritization"); if (prioritizedSources != null) SourcePrioritization = splitValue(prioritizedSources); }
private void build(string[] args) { string source = args[1]; string destination = null; if (args.Length == 3) { destination = Path.GetFullPath(args[2]); } else { var setting = new ConfigReader(_token).Get("default.package.destination"); if (setting != null) destination = setting; } if (!Directory.Exists(destination)) return; string name; string dir; string command; string packageFile; var package = getPackages() .FirstOrDefault(x => x.ID == source); if (package == null) { var packageDefinition = ""; if (File.Exists(source) && Path.GetFileName(source) == "package.json") { packageDefinition = source; } else { source = Path.GetFullPath(source); dir = Path.GetDirectoryName(source); name = Path.GetFileNameWithoutExtension(source); packageDefinition = Path.Combine(Path.Combine(dir, name + "-files"), "package.json"); if (!File.Exists(packageDefinition)) { _dispatch("error|Cannot find package.json. Run package init to create one"); return; } } package = Package.Read(packageDefinition); } name = package.ID; command = package.Command; dir = Path.GetDirectoryName(Path.GetDirectoryName(package.File)); packageFile = package.File; destination = Path.GetFullPath(destination); var appDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); new Process() .Query( Path.Combine(Path.Combine(appDir, "Packaging"), "oipckmngr.exe"), string.Format("build \"{0}\" \"{1}\" \"{2}\" \"{3}\"", name, command, dir, destination), false, Environment.CurrentDirectory, (err, line) => { Console.WriteLine(line); }); _dispatch("event|builtin package built \"" + packageFile + "\""); }
public static CommandEndpoint GetEndpoint(string path, string[] enabledLanguages) { _path = path; var reader = new ConfigReader(_path); _interpreters = new Interpreters(_path); ProcessExtensions.GetInterpreter = (file) => { var interpreters = _interpreters .GetInterpreterFor(Path.GetExtension(file)); return interpreters; }; _cache = new TypeCache(); _outputEndpoint = new OutputEndpoint(_path); Logger.Write("Event endpoint serving on port: {0}", _outputEndpoint.Port); var responseDispatcher = new ResponseDispatcher( _path, false, "language-output ", (p, m) => _outputEndpoint.Send(p, m), (m) => _endpoint.Handle(m), (m) => {} ); responseDispatcher.OnlyCommands(); _pluginLocator = new PluginLocator( enabledLanguages, new ProfileLocator(_path), (msg) => { responseDispatcher.Handle(false, msg); } ); initPlugins(_pluginLocator); _eventEndpoint = new EventEndpoint(_path, _pluginLocator, _outputEndpoint); _eventEndpoint.Start(); Logger.Write("Event endpoint listening on port: {0}", _eventEndpoint.Port); Logger.Write("Creating plugin file tracker"); _tracker = new PluginFileTracker(); Logger.Write("Starting plugin file tracker"); var ignoreDirSetting = reader.Get("oi.ignore.directories"); var ignoreDirectories = new string[] {}; if (ignoreDirSetting != null) { ignoreDirectories = ignoreDirSetting .Split(new[] {','}) .Select(x => { if (Path.IsPathRooted(x)) { return x; } return Path.Combine(_path, x); }) .ToArray(); } _tracker.Start( _path, _cache, _cache, _pluginLocator, _eventEndpoint, ignoreDirectories); Logger.Write("Plugin file tracker started"); _endpoint = new CommandEndpoint(_path, _cache, _eventEndpoint); _endpoint.AddHandler(messageHandler); _handlers.AddRange(new IHandler[] { new GetProjectsHandler(_endpoint, _cache), new GetFilesHandler(_endpoint, _cache), new GetCodeRefsHandler(_endpoint, _cache), new GetSignatureRefsHandler(_endpoint, _cache), new GoToDefinitionHandler(_endpoint, _cache, _pluginLocator), new FindTypeHandler(_endpoint, _cache), new SnippetEditHandler(_endpoint, _cache, _path), new SnippetDeleteHandler(_cache, _path), new GetRScriptStateHandler(_endpoint, _eventEndpoint), new CompleteSnippetHandler(_cache, _path, _endpoint), new WriteOutputHandler(_eventEndpoint), new GetTokenPathHandler(_endpoint), // Make sure this handler is the last one since the command can be file extension or language name new LanguageCommandHandler(_endpoint, _cache, _pluginLocator) }); Logger.Write("Command endpoint started"); return _endpoint; }
private void printMergedConfig(string path) { Console.WriteLine("Configuration for: " + path); Console.WriteLine(); var reader = new ConfigReader(path); foreach (var key in reader.GetKeys().OrderBy(x => x)) { Console.WriteLine("\t{0}={1}", key, reader.Get(key)); } }
private string getLogFileArgument(string token) { var config = new ConfigReader(token); var path = config.Get("oi.logpath"); if (path == null) return ""; return " \"--logging=" + Path.Combine(path, "EditorEngine.log") + "\""; }
public void Execute(string[] arguments) { Logger.Write ("Getting editor instance"); var instance = _editorFactory.GetInstance(_rootPath); // TODO remove that unbeleavable nasty setfocus solution. Only init if launching editor var isSetfocus = arguments.Length > 0 && arguments[0] == "setfocus"; if (instance == null && arguments.Length >= 0 && !isSetfocus) { var args = new List<string>(); Logger.Write("Reading configuration from " + _rootPath); var configReader = new ConfigReader(_rootPath); if (arguments.Length == 0) { var name = configReader.Get("default.editor"); if (name == null) { Console.WriteLine("To launch without specifying editor you must specify the default.editor config option"); return; } args.Add(name); } else { args.AddRange(arguments); } var editorName = args[0]; args.AddRange( configReader .GetStartingWith("editor." + editorName) .Select(x => "--" + x.Key + "=" + x.Value)); if (!_environment.HasEditorEngine(_rootPath)) { if (!_environment.StartEditorEngine(args, _rootPath)) { Console.WriteLine("Could not launch editor " + args[0]); return; } } if (!_environment.HasEditorEngine(_rootPath)) { Console.WriteLine("Could not launch editor " + args[0]); return; } if (!_environment.IsRunning(_rootPath)) _environment.Start(_rootPath); } else if (arguments.Length >= 1 && arguments[0] == "get-dirty-files") { if (instance == null) return; string file = null; if (arguments.Length > 1) file = arguments[1]; Console.WriteLine(instance.GetDirtyFiles(file)); } else { if (instance == null) return; instance.Run(arguments); } }
public void Execute(string[] arguments) { Logger.Write ("Getting editor instance"); var instance = _editorFactory.GetInstance(_rootPath); // TODO remove that unbeleavable nasty setfocus solution. Only init if launching editor var isSetfocus = arguments.Length > 0 && arguments[0] == "setfocus"; if (instance == null && arguments.Length >= 0 && !isSetfocus) { var args = new List<string>(); Logger.Write("Reading configuration from " + _rootPath); var configReader = new ConfigReader(_rootPath); if (arguments.Length == 0) { var name = configReader.Get("default.editor"); if (name == null) { Console.WriteLine("To launch without specifying editor you must specify the default.editor config option"); return; } args.Add(name); } else { args.AddRange(arguments); } var editorName = args[0]; args.AddRange( configReader .GetStartingWith("editor." + editorName) .Select(x => "--" + x.Key + "=" + x.Value)); // A bit of a hack but if we find a configuration called executable for the editor // if the path is rooted (avvoids checking for files in PATH) display a warning // if it does not exist. var executableSetting = configReader.Get("editor." + editorName + ".executable"); if (executableSetting != null) { if (Path.IsPathRooted(executableSetting)) { if (!File.Exists(executableSetting)) _dispatch("warning|The configured path for the " + editorName + " editor does not exist: " + executableSetting); } } if (!_environment.HasEditorEngine(_rootPath)) { if (!_environment.StartEditorEngine(args, _rootPath)) { Logger.Write("Could not launch editor " + args[0]); return; } } if (!_environment.HasEditorEngine(_rootPath)) { Logger.Write("Could not launch editor " + args[0]); return; } if (!_environment.IsRunning(_rootPath)) { _environment.Start(_rootPath); } } else if (arguments.Length >= 1 && arguments[0] == "get-dirty-files") { if (instance == null) return; string file = null; if (arguments.Length > 1) file = arguments[1]; Console.WriteLine(instance.GetDirtyFiles(file)); } else if (arguments.Length == 1 && arguments[0] == "get-caret") { Console.WriteLine(instance.GetCaret()); } else if (arguments.Length == 3 && arguments[0] == "user-select") { instance.UserSelect(arguments[1], arguments[2]); } else if (arguments.Length >= 2 && arguments[0] == "user-input") { var defaultvalue = ""; if (arguments.Length > 2) defaultvalue = arguments[2]; instance.UserInput(arguments[1], defaultvalue); } else if (arguments.Length == 1 && arguments[0] == "get-windows") { Console.WriteLine(instance.GetWindows()); } else { if (instance == null) return; instance.Run(arguments); } }
private void userSelect(MessageArgs message, Editor editor) { var state = new ConfigReader(_endpoint.Token).Get("oi.userselect.ui.fallback"); if (state == "disabled") return; _ctx.Post((s) => { try { var args = new CommandStringParser().Parse(message.Message).ToArray(); var items = new List<string>(); var keys = new List<string>(); foreach (var item in args[3].Split(new[] {','})) { var chunks = item.Split(new[] {"||"}, StringSplitOptions.None); if (chunks.Length > 1) { keys.Add(chunks[0]); items.Add(chunks[1]); } else { keys.Add(item); items.Add(item); } } var command = "user-selected"; if (message.Message.StartsWith("user-select-at-caret ")) command = "user-selected-at-caret"; var form = new UserSelectForm(items, keys, (item) => { if (item != null) _endpoint.PublishEvent(command+" '" + args[2] + "' '" + item + "'"); else _endpoint.PublishEvent(command+" '" + args[2] + "' 'user-cancelled'"); editor.SetFocus(); }); form.Show(this); setToForeground(form); } catch { } }, null); }
private void userInput(MessageArgs message, Editor editor) { Logger.Write("Getting state for userinput fallback"); var state = new ConfigReader(_endpoint.Token).Get("oi.userinput.ui.fallback"); Logger.Write("State is "+state); if (state == "disabled") return; _ctx.Post((s) => { Logger.Write("Launching user input form"); try { var args = new CommandStringParser().Parse(message.Message).ToArray(); var defaultValue = ""; if (args.Length > 3) defaultValue = args[3]; var form = new UserInputForm(defaultValue, (item) => { if (item != null) _endpoint.PublishEvent("user-inputted '" + args[2] + "' '" + item + "'"); else _endpoint.PublishEvent("user-inputted '" + args[2] + "' 'user-cancelled'"); editor.SetFocus(); }); form.Show(this); setToForeground(form); } catch (Exception ex) { Logger.Write(ex); } }, null); }