Script intelligent string match and modify in batch file

Question

I have multiple text (.cs) files that all have a line similar to this:

public partial class ApiIThis :  IEquatable<ApiIThis>

or

public partial class ApiIThat :  IEquatable<ApiIThat>

I need to transform them into

public partial class ApiIThis :  IEquatable<ApiIThis>, IThis
public partial class ApiIThat :  IEquatable<ApiIThat>, IThat

This will be run in a .bat file that needs to run in a Windows command line environment

Update: To answer @aschipfl

What have you tried so far, what do you have problems with? Please share your efforts by adding the information to the question!

What I have tried so far is doing some google searching to find some examples of what I'm trying to do. I found an SO post (How to replace substrings in windows batch file) that seems somewhat related, but it wasn't enough to get me going.

Anyway, do the .cs files only have lines like you showed, or even one only?

No, these will not be the only lines in the files. These files will have the full C# class auto-generated by a Swagger tool.

Do you need to find them between other lines, and if so, by what criteria?

Yes they will be between other lines. However, it will be the only line like this in the file. The file has the definition like:

using Something;
using SomethingElse;

public partial class ApiIThis :  IEquatable<ApiIThis>
{
    public ApiIThis() 
    { 
        /* Other code here */ 
    }

    /* Other code here */ 
}

Do the words after class and in between always match?

Yes, they will always match.

Could the words contain white-spaces?

No, they will never contain white-space.

Do you want to collect the transformed lines in a single output file, or do you want a separate output file per input file? or do you even want to overwrite/replace the original files?

I want the original file to be updated.

Finally I wanted to add that they will all start with Api, actually ApiI

Answer 1

@echo off
setlocal EnableDelayedExpansion

rem Process all *.cs files
for %%a in (*.cs) do (
   echo Processing "%%a"

   rem Get the number of the target line
   for /F "delims=:" %%b in ('findstr /N /C:"public partial class" "%%a"') do set /A "skip=%%b-1"

   rem Read from original file
   < "%%a" (

      rem Copy previous lines
      for /L %%i in (1,1,!skip!) do (
         set "line="
         set /P "line="
         echo/!line!
      )

      rem Process target line
      set /P "line="
      for /F "tokens=4,6" %%b in ("!line!") do (
         set "Api=%%b"
         echo public partial class %%b :  %%c, !Api:~3!
      )

      rem Copy rest of lines
      findstr "^"

   rem Write to new file
   ) > "%%~Na.new"

   move /Y "%%~Na.new" "%%a"
)

EDIT: I tested this solution with the files provided by the OP. The surprise was that such files does NOT end in CR+LF pairs, but just in LF (Linux style), so they must be converted into CR+LF standard in order to be processed by a Batch file (that uses Windows standard).

I converted the files using more command this way:

for %a in (*.cs) do more %a > %~Na.new
del *.cs
ren *.new *.cs

After that the conversion was correct, excepting for the 4 spaces at beginning of the line that may be directly inserted in the corresponding echo command.

C:\> test.bat
Processing "ApiIClaim.cs"
Processing "ApiIClaimType.cs"
Processing "ApiIMonetaryType.cs"


C:\> for %a in (*.cs) do @fc %a %~Na.new
Comparando archivos ApiIClaim.cs y APIICLAIM.NEW
***** ApiIClaim.cs
    [DataContract]
    public partial class ApiIClaim :  IEquatable<ApiIClaim>
    {
***** APIICLAIM.NEW
    [DataContract]
public partial class ApiIClaim :  IEquatable<ApiIClaim>, IClaim
    {
*****

Comparando archivos ApiIClaimType.cs y APIICLAIMTYPE.NEW
***** ApiIClaimType.cs
    [DataContract]
    public partial class ApiIClaimType :  IEquatable<ApiIClaimType>
    {
***** APIICLAIMTYPE.NEW
    [DataContract]
public partial class ApiIClaimType :  IEquatable<ApiIClaimType>, IClaimType
    {
*****

Comparando archivos ApiIMonetaryType.cs y APIIMONETARYTYPE.NEW
***** ApiIMonetaryType.cs
    [DataContract]
    public partial class ApiIMonetaryType :  IEquatable<ApiIMonetaryType>
    {
***** APIIMONETARYTYPE.NEW
    [DataContract]
public partial class ApiIMonetaryType :  IEquatable<ApiIMonetaryType>, IMonetaryType
    {
*****

Answer 2

The following script -- let us call it append-keyword.bat -- does what you want. To use it, provide all the files to process as command line arguments; wildcards ? and * are also allowed:

@echo off
setlocal EnableExtensions DisableDelayedExpansion

set "TMPF=%TEMP%\%~n0_%RANDOM%.tmp"
:LOOP
set "ARGF=%~1"
if defined ARGF (
    setlocal EnableDelayedExpansion
    for %%F in ("!ARGF!") do (
        endlocal
        if /I not "%%~fF"=="%~f0" (
            set "FILE=%%~fF"
            setlocal EnableDelayedExpansion
            if exist "!FILE!" if not exist "!FILE!\" (
                rem /* (it's a file but not a dir. due to "\") */
                > "!TMPF!" call :PROCESS MOV "!FILE!"
                if defined MOV (
                    > nul move /Y "!TMPF!" "!FILE!"
                ) else (
                    > nul del "!TMPF!"
                )
            )
        ) else (
            setlocal EnableDelayedExpansion
        )
    )
    endlocal
    shift /1
    goto :LOOP
)

endlocal
exit /B


:PROCESS  return  item
setlocal DisableDelayedExpansion
set "ITEM=%~2"
set "RTN="
setlocal EnableDelayedExpansion
for /F delims^=^ eol^= %%L in ('findstr /N /R "^^" "!ITEM!"') do (
    endlocal
    set "LINE=%%L"
    set "SKIP="
    rem // Default delimiters TAB and SPACE:
    setlocal EnableDelayedExpansion
    for /F "eol=/ tokens=1-3,*" %%A in ("!LINE:*:=!") do (
        endlocal
        if "%%A %%B %%C"=="public partial class" (
            rem // Delimiters `:`, TAB and SPACE:
            for /F "eol=/ tokens=1,* delims=:    " %%E in ("%%D") do (
                rem // Delimiters `<`:
                for /F "eol=/ tokens=1,* delims=<" %%G in ("%%F") do (
                    if "%%G"=="IEquatable" (
                        rem // Delimiters `>`, `,`, TAB and SPACE:
                        for /F "eol=/ tokens=1,* delims=>,   " %%I in ("%%H") do (
                            if "%%J"=="" (
                                if "%%E"=="%%I" (
                                    set "STR=%%E"
                                    setlocal EnableDelayedExpansion
                                    if "!STR:~,3!"=="Api" (
                                        echo(!LINE:*:=!, !STR:~3!
                                        endlocal
                                        set "SKIP=#"
                                    ) else (
                                        endlocal
                                    )
                                )
                            )
                        )
                    )
                )
            )
        )
        setlocal EnableDelayedExpansion
    )
    if not defined SKIP (
        echo(!LINE:*:=!
    ) else (
        endlocal
        set "RTN=#"
        setlocal EnableDelayedExpansion
    )
)
endlocal
endlocal & set "%~1=%RTN%"
exit /B

The main routine accomplishes the following tasks:

• handle the command line arguments, loop through them;
• resolve wildcards by a for loop;
• exclude the script itself to be processed;
• check each file for existence;
• write the return data of the sub-routine to a temporary file;
• move the temporary file over the processed file in case of changes;

The sub-routine performs the following actions:

• read the given file line by line (even empty lines);
• check for words public, partial, class in this order, not regarding the number of white-spaces in between; (regard that it is not checked whether the words are followed by a colon!)
• check for word IEquatable, followed by <, some more text and >;
• check if the above text is followed by something else (if yes, the line/file has already been processed, so skip it);
• check if the words after class and in between < and > match; (regard that the latter string must not contain <, > or , on its own!)
• check if that word begins with Api, cut it off and append the remaining string to the line, separated by , and a SPACE;
• return (echo) the modified line or the original one, depending on whether all of the above checks succeed;
• return a flag indicating whether or not any line has been altered;
• conduct all string comparisons in a case-sensitive manner;

Answer 3

Filtering (with PowerShell)

Here's a script that uses PowerShell (comes with all Windows since Vista, installed on XP via an update).

Param(
    [String]
    $input_file
)

Function Filter-Data
{
    Param(
        [Parameter(ValueFromPipeline=$True)]
        [String]
        $line
    )
    Process {
        if ($line -match "public\s+partial\s+class\s+ApiI([A-Za-z0-9_]+)\s*:\s*IEquatable\s*<\s*ApiI[A-Za-z0-9_]+\s*>") {
            Return $matches[0] + ", " + $matches[1]
        } Else {
            Return $line
        }
    }
}

Get-Content $input_file | Filter-Data | Write-Host

You give it the input file name. It spits out the filtered data. You may want to make the filtering more intelligent (allowing spaces, etc.), but what's here will do the trick.

Invocation might look like this:

PowerShell -NoProfile -ExecutionPolicy Bypass -File filter.ps1 source_file.cs <NUL

Notes

• -NoProfile will tell PoSH not to load the user's profile (faster startup)
• -ExecutionPolicy must allow files, and if you haven't configured one on your machine, you'll want to specify ByPass so that PoSH will run the script.
• <NUL PowerShell frequently waits for you to hit ENTER before completing execution. Redirecting nothing in will return control to the caller as soon as the script is done.

EDIT based on further detail added to the question and the comment about triviality, I updated the filtering code to match and replace more generally. It also allows spaces between C# tokens, even though that wasn't an official requirement (I don't wholly trust code generators).