Exemple #1
0
        public override void OnExecute(Ommel loader, Mod mod)
        {
            loader.RegisterModifiedFile(TargetFile);
            var source_path = mod.GetFile(SourceFile);

            var parsed_script = LuaParser.ParseFile(loader.ExpandTargetPathDefaulted(TargetFile));

            if (parsed_script == null)
            {
                throw new Exception($"Failed parsing '{TargetFile}'");
            }
            var ast_search = new ASTSearchWalker();

            ast_search.Match(LuaInsertTarget, parsed_script);

            if (!ast_search.HasSelection)
            {
                throw new Exception($"AST search failed");
            }

            var offset = ast_search.SelectedSpan.Value.Location.Position;

            string s;

            using (var target_file = new StreamReader(File.OpenRead(loader.ExpandTargetPathDefaulted(TargetFile)))) {
                using (var source_file = new StreamReader(File.OpenRead(source_path))) {
                    s = InsertAtPos(target_file, offset, source_file, Trim);
                }
            }

            loader.DeleteFile(TargetFile);

            using (var output = new StreamWriter(loader.OpenWriteTarget(TargetFile))) {
                output.Write(loader.ProcessNewlines(s.ToString()));
            }

            if (loader.ExtraChecks)
            {
                Logger.Debug($"Checking result to see if it's still valid");
                var parsed_new_script = LuaParser.ParseFile(loader.ExpandTargetPath(TargetFile));
                if (parsed_new_script == null)
                {
                    Logger.Warn($"Insertion broke Lua script");
                }
                else
                {
                    var test_ast_search = new ASTSearchWalker();
                    test_ast_search.Match(LuaInsertTarget, parsed_new_script);

                    if (!test_ast_search.HasSelection)
                    {
                        Logger.Warn($"AST query no longer resolves after insertion");
                    }
                }
            }

            DoReplaceIfRequested(mod, loader, TargetFile);
        }
        public override void OnExecute(Ommel loader, Mod mod)
        {
            var param_counter = 0;

            if (Line != null)
            {
                param_counter += 1;
            }
            if (Offset != null)
            {
                param_counter += 1;
            }
            if (param_counter == 0)
            {
                throw new Exception($"Missing location parameter - choose either 'Line' or 'Offset'");
            }
            if (param_counter > 1)
            {
                throw new Exception("Too many parameters given to TextInsert - choose either 'Line' or 'Offset'");
            }

            loader.RegisterModifiedFile(TargetFile);
            var source_path = mod.GetFile(SourceFile);

            StringBuilder s = new StringBuilder();

            string data_to_be_inserted = null;

            using (var source_file = new StreamReader(File.OpenRead(source_path))) {
                data_to_be_inserted = source_file.ReadToEnd();
                if (Trim)
                {
                    data_to_be_inserted = data_to_be_inserted.Trim();
                }
            }


            var string_map = mod.LoadReplacementMap(PlaceholderFile);

            if (string_map == null && Placeholders != null)
            {
                Logger.Warn($"File operation requested to use placeholders, but there is no string map file");
                return;
            }
            else if (string_map != null && Placeholders != null)
            {
                data_to_be_inserted = mod.ReplaceStrings(string_map, Placeholders.ToArray(), mod.Ommeldata.PlaceholderPrefix, mod.Ommeldata.PlaceholderSuffix, data_to_be_inserted);
            }

            if (Offset != null)
            {
                using (var target_file = new StreamReader(File.OpenRead(loader.ExpandTargetPathDefaulted(TargetFile)))) {
                    var target_pre_data = new char[Offset.Value];
                    target_file.Read(target_pre_data, 0, Offset.Value);
                    s.Append(target_pre_data);
                    s.Append(data_to_be_inserted);
                    s.Append(target_file.ReadToEnd());
                }
            }
            else if (Line != null)
            {
                using (var target_file = new StreamReader(File.OpenRead(loader.ExpandTargetPathDefaulted(TargetFile)))) {
                    var line_idx = 1;
                    while (!target_file.EndOfStream)
                    {
                        if (line_idx == Line.Value)
                        {
                            s.Append(data_to_be_inserted);
                        }
                        s.AppendLine(target_file.ReadLine());
                        line_idx += 1;
                    }
                }
            }

            loader.DeleteFile(TargetFile);

            using (var output = new StreamWriter(loader.OpenWriteTarget(TargetFile))) {
                output.Write(loader.ProcessNewlines(s.ToString()));
            }
        }