should powershell provide a cross platform scriptable file editor?

[JamesWTruher]

The platforms have had scriptable editors for ever. Unix had ed and for Windows it was edlin. Both of these tools are pretty arcane from a usage perspective, but they filled a need. When PS first started out on Windows, most configuration was found in the registry but there still were opportunities to automate editing files. When we went cross platform, there are more opportunities for file editing (I've found myself scripting ed on more than a couple instances). Those of us that have needed this usually write a bit of bespoke code to handle it. I know that @rkeithhill started down this path as well (there's an old PR of his in the textutility module).

Should PowerShell provide a similar experience (but perhaps less arcane, and perhaps more verbose)?

I've been working on a possible approach for this and I call it (creatively enough) Edit-File. I was inspired by ed and It works by taking discrete actions and allow you to aggregate them into a set of editing instructions.

Here's an example of how it works - editing the sshd_config file.

PS> $actions = @(
    @{ Action = "SearchForward"; Pattern = "#PasswordAuthentication" }
    @{ Action = "Replace"; Pattern = "#PasswordAuthentication.*"; Replacement = "PasswordAuthentication`tyes"; Predicate ="PreviousSuccess"}
    @{ Action = "Position"; Position = "Begin" }
    @{ Action = "SearchForward"; Pattern = "^Subsystem.*Powershell" }
    @{ Action = "AppendLine"; Line = "Subsystem`tPowerShell`t/usr/local/bin/pwsh -sshs -nologo"; Predicate = "PreviousFailure" }
    @{ Action = "Position"; Position = "Begin" }
    @{ Action = "SearchForward"; Pattern = "#Subsystem.*PowerShell" }
    @{ Action = "Delete"; Predicate = "PreviousSuccess" }
    @{ Action = "Save" }
)
PS> Edit-File -file sshd_config -action $actions -backup

It should be pretty obvious what it does. Is this interesting? useful? could it be?

[rkeithhill]

I love it and I really like being able to specify multiple actions. Feels a bit like manipulating a document via an editor's API. I wonder if there could be a simple way to do replace edits e.g.:

Edit-File -file /etc/resolv.conf -action Replace -Pattern "^(?<=nameserver\s).*" -Replacement "8.8.8.8"

Edit-File would be super helpful in our Ansible scripts and build scripts. One of the first things we do in our Jenkins builds is to scribble in an updated prerelease suffix for that build's semver version number into various files: buildInfo.h, .nuspec, package.json, conanfile.py, etc.

[JamesWTruher]

one of the things I didn't mention is that what I've done has a "you better know what you're doing ed mode". The first 2 actions in my example above could be

"sf/#PasswordAuthentication","r/#PasswordAuthentication/PasswordAuthentication`tyes"

I haven't thought about what the predicate checks would look like in this syntax, though.

The predicate check stuff allows you to base an action on the result of the previous action. So if a search failed, you could not take a replacement action. I definitely don't want to build in branching/looping logic at this point, but still wanted a way to skip an action under certain circumstances

[dkattan]

I wrote something similar and I like syntax like this:

XMLShould-Be $OpenDentalXml "/ConnectionSettings/DatabaseConnection/ComputerName"   -Value $Hostname -Set
XMLShould-Be $OpenDentalXml "/ConnectionSettings/DatabaseConnection/Database"       -Value $Database -Set

I have a similar one for INI files

I tried to do something similar with JSON but there doesn't appear to be built in .net support for JsonPath yet

I just like the idea of using native format handlers instead of just regex

[JamesWTruher]

yah - that's what I've observed - a number of folks have this sort of problem and have their own bespoke solutions. I was thinking about a more generalized approach to scripted editing of text files.

Modifying XML is somewhat handy because of the built-in structure of the xml (and XPath sorts of query seems like a natural approach)

[rkeithhill]

I have no issues using regex if it gets the job done across a wide variety of text file types. For XML, I'm more likely to load the doc as [xml] and use the XML API and/or PowerShell's ETS to edit it.

[Jaykul]

There's a part of me that looked at the example and thought: oh man, the "PowerShell is too verbose" people are going to have a field day ... but honestly, I'm just never going to get tired of saying: yeah, but you can tell what this does, even though you've never tried it!

So I like the idea, and I like the readability -- but I want it to be blindingly fast at the core automation functionality like (regex) search and replace.

As far as the example, personally, I would prefer an Actions syntax more like a macro DSL, and less like a JSON list. I think it would be more readable and less typing:

SearchForward -Pattern "#PasswordAuthentication"
Replace -Pattern "#PasswordAuthentication.*" -Replacement "PasswordAuthentication`tyes" -Predicate PreviousSuccess
Position -Position Begin
SearchForward -Pattern "^Subsystem.*Powershell"
...

If it's going to have an interactive mode, I want it to at least have syntax highlighting (e.g. via textmate grammars), and in the interest of usability, I personally think it should always have a (status) bar when it starts (like nano): something that tells newbies how to do the things they need to do (save, undo, exit, hide the bar ...). And of course, it has to work remotely over SSH, at least 😉

On that note, I think you need to consider and be clear, up front, about what the priorities for the project are. E.g.: what's most important: speed vs code readability, speed vs features, automation vs interaction ...

[JamesWTruher]

current implementation is all in memory, and pretty peppy. saves are not incremental, but explicit, which helps with speed.
It's probably not going to be good to edit huge files (millions of lines), but if you have that problem, you're in trouble anyway.
Also, current implementation is all in PowerShell, I can see a rewrite into c# which would make it much better from a performance perspective.

One thing I didn't show is the verbose output which essentially emits the action and its status in flight. I have vague notions about adding events so you can "watch" execution as well.

[kasini3000]

Powershell is the best engine in the world, and I use it to make the best cars.

Powershell fans:
Please discard ansible and use kasini3000.
For finding and replacing, please use my powershell script psed.ps1
Simply put, it has three search patterns:

• lines,
• strings,
• matches at the beginning and end.

Its search and replacement do not support regularization.
Not supporting regularization makes it simpler and more reliable.
But it supports replacing with code: -rf {scriptblock with regularization}

---

Supports SSH, WinRM, and remote work.

https://gitee.com/chuanjiao10/kasini3000/blob/master/docs/ps%E6%89%BE%E7%AE%97%E6%9B%BF_v3_readme.html

download to local and translate

https://gitee.com/chuanjiao10/kasini3000/blob/master/node_script/kasini3000/psed.ps1

/path/psed.ps1 -infile /tmp/a.txt -find 'SELINUX=disabled' -replace 'xxx1'
Welcome to submit bugs and comments

[mattcargile]

Looks cool like a sed clone. Would it be worth it to review more examples of that tool to implement? Here is a reference I was looking at.

Should there be a way to ignore case or replace a certain occurrence of a pattern? Are there any other features of sed that could be added?

I agree that it should be fast. And I would want to see tab completion on the actions. And I'd like to see less verbose usage for advanced users who are working interactively.