Sublime Forum

**facelessuser** · January 13, 2016, 9:00am

There was an ST3 fix backported to ST2, but I mistakenly released the ST2 release from the wrong branch. Release 1.10.1 for ST2 should fix this issue when available in Package Control.

**TheoryX** · January 13, 2016, 9:02am

I’m trying to replace few characters in my text, for example “š” with “\v{s}” but it doesn’t work

for replace with “\v{s}” i get error: Error trying to parse settings: Invalid escape in Packages/RegReplace/reg_replace.sublime-settings:87:24
for replace with “\v{s}” it just changes to: ‘vertical tab sign’{s}

can someone please explain how to keep \v?

**facelessuser** · January 13, 2016, 9:02am

\v is not a recognized back reference. Since you are suing Python’s re regex module, you need to use something that works with that, so here is a simple example:

"unicode_test": { "find": "replace me", "replace": "<verttab>\u000B<verttab>" }

Good luck!

**facelessuser** · January 13, 2016, 9:04am

2.2.0 is out.

Adds a number of improvements to handling upper case and lower case back references in replace patterns.
It also adds support for escaping characters with \Q…\E in search patterns.
Adds upper\lower case character classes via \l and \c in search or the inverse via \L and \C (if re.Unicode flag is enabled, they will act as unicode character classes).
Also adds support for unicode properties via \p{Letter_Number} or \p{Nl} or the inverse form \P{Letter_Number} or \P{Nl} etc. It is just limited to the general property classes.

Anyways, read more here facelessuser.github.io/RegReplac … references.

**facelessuser** · January 13, 2016, 9:04am

2.2.1 update

Added some fixes for the extended backrefs where some situations it would not be able to detect inline (?x) or (?u) flags to alter the parsing logic. I doubt anyone ran into the issue as you would have to bury the flags in a non usual way, but anyways, it should be fine now.

**mateuszfryc** · December 11, 2016, 1:57pm

Hello,
I’m having problem with Reg Replace. I’ve received a lot of poems lyrics in .txt format (I’m not programist). Problem is they all have been saved with wrong encoding which resulted with replacing all national characters (I’m from Poland) to their equivalent in Unicode. I was looking for a tool which would allow me to batch all files at once and I bumped to Reg Replace for STE. I have installed Reg Replace using Package Controll and decided to do one file at the time. Fallowing this instructions:

see here

I’ve put in reg_replace.sublime-settings fallowing code:

`{
  "replacements": {
    "pl1": {
      "find": "ê",
      "replace": "ę",
      "greedy": true,
      "case": false,
      "literal": true
    },
    "pl2": {
      "find": "¿",
      "replace": "ż",
      "greedy": true,
      "case": false,
      "literal": true
    },
    "pl3": {
      "find": "³",
      "replace": "ł",
      "greedy": true,
      "case": false,
      "literal": true
    },
    "pl4": {
      "find": "¹",
      "replace": "ą",
      "greedy": true,
      "case": false,
      "literal": true
    },
    "pl5": {
      "find": "Ÿ",
      "replace": "ź",
      "greedy": true,
      "case": false,
      "literal": true
    },
    "pl6": {
      "find": "œ",
      "replace": "ś",
      "greedy": true,
      "case": false,
      "literal": true
    },
    "pl7": {
      "find": "æ",
      "replace": "ć",
      "greedy": true,
      "case": false,
      "literal": true
    }
  }
}`

Than I’ve put this code into Default.sublime-commands:

[
  {
    "caption": "Reg Replace: Polish characters",
    "command": "reg_replace",
    "args": {
      "replacements": [
        "pl1",
        "pl2",
        "pl3",
        "pl4",
        "pl5",
        "pl6",
        "pl7"
      ]
    },
    "find_only": true
  }
]

In the end I hit Ctrl + Shift + P and by typing “Polish characters” (name of my command), I find it, hit Enter and nothing happens. No error, no changes to opened document. Normally I would attempt some kind of trouble shooting, but I know only basis of Java Script and PHP. What I should check, where to read?

I’m using latest version of Sublime and running Windows 7 x64 Pro.

**facelessuser** · December 11, 2016, 5:52pm

@mateuszfryc, as tempting as it is to follow someone’s guide on the internet, there is no guarantee it is up to date – in this case, the guide you followed is very outdated.

The official user guide is here: http://facelessuser.github.io/RegReplace/usage/#create-find-and-replace-sequences.
Documentation states that replacement rules are now defined in reg_replace_rules.sublime-settings.
You can’t use the argument case anymore as it is no longer valid. Case sensitivity is true by default as it is in the regular expression engine. If you need to do a non literal replacement sequence, you use Python’s regular expression case insensitive flag of (?i). If doing a literal example as you are doing, you use the flag literal_ignorecase option as the find rule will now be parsed literally not accounting the flag.

Examp
```
/* For literal: */
"pl1": {
  "find": "ê",
  "replace": "ę",
  "greedy": true,
  "literal_ignorecase": true,
  "literal": true
},
/* non-literal */
"pl1": {
  "find": "(?i)ê",
  "replace": "ę",
  "greedy": true
},
```
You made a mistake with your command, the find_only argument should have been under args.

In the next version to be released, I have a quick start guide available in Preferences -> Package Settings -> RegReplace -> Quick Start Guide but unfortunately it is taking a while for a new regex module dependency to get merged on Package Control. I can’t make a new release until that gets merged:

You can read the quick start guide here:

github.com

facelessuser/RegReplace/blob/master/quickstart.md

# Getting Started

RegReplace allows you to create find and replace rules and chain them together in one command. You can even setup  
sequences to execute on file save.  Out of the box, RegReplace does nothing as you have to setup the find and replace  
rules and commands you want to use first.

RegReplace also allows you to assign alternative actions to the replace.  For example, you could find and fold.  You  
could find and select.  You could even find and mark (highlight).  All of these are covered more in the [documentation](http://facelessuser.github.io/RegReplace/usage/#override-actions).

# Creating a Rule

This is a simple example of a find and replace rule to remove trailing spaces.

1. Press <kbd>ctrl</kbd> + <kbd>shift</kbd> + <kbd>p</kbd> (or <kbd>cmd</kbd> + <kbd>shift</kbd> + <kbd>p</kbd> on OSX)  
to bring up the command palette.

2. Type `RegReplace` to see all the RegReplace commands and select `RegReplace: Create New Regular Expression`.  You  
will be presented with an output panel.  In the output panel will be all the rule options.

3. In this example we will create a rule that looks for trailing spaces.  We will replace those trailing spaces with

This file has been truncated. show original

Anyways, this is what I did to get your example to work:

Edit reg_relace_rules.sublime_settings and add this:

{
    "format": "3.0",
    "replacements":
    {
        "pl1": {
          "find": "ê",
          "replace": "ę",
          "greedy": true,
          "literal_ignorecase": true,
          "literal": true
        },
        "pl2": {
          "find": "¿",
          "replace": "ż",
          "greedy": true,
          "literal_ignorecase": true,
          "literal": true
        },
        "pl3": {
          "find": "³",
          "replace": "ł",
          "greedy": true,
          "literal_ignorecase": true,
          "literal": true
        },
        "pl4": {
          "find": "¹",
          "replace": "ą",
          "greedy": true,
          "literal_ignorecase": true,
          "literal": true
        },
        "pl5": {
          "find": "Ÿ",
          "replace": "ź",
          "greedy": true,
          "literal_ignorecase": true,
          "literal": true
        },
        "pl6": {
          "find": "œ",
          "replace": "ś",
          "greedy": true,
          "literal_ignorecase": true,
          "literal": true
        },
        "pl7": {
          "find": "æ",
          "replace": "ć",
          "greedy": true,
          "literal_ignorecase": true,
          "literal": true
        }
    }
}

Place this command in Default.sublime-commands:

    {
        "caption": "Reg Replace: Polish characters",
        "command": "reg_replace",
        "args": {
            "replacements": [
                "pl1",
                "pl2",
                "pl3",
                "pl4",
                "pl5",
                "pl6",
                "pl7"
            ],
            "find_only": true
        }
    }

And with the following text in a file ê¿³¹Ÿœæ, you can run the command and replace and get ężłąźść.

**mateuszfryc** · December 11, 2016, 8:26pm

@facelessuser thank you! I’ve fixed what you said and now it works perfectly

**facelessuser** · December 12, 2016, 1:25am

You’re welcome :).

**Carpenter** · March 4, 2017, 10:51am

Thank you for your plugin, it looks promising.

I need to find all “GetSheHe” in a scope defined in my syntax file.
meta.block.french.csv is the scope (all characters between the second and the third semicolon
in each line)

In Default.sublime-commands:

{
    "caption": "Reg Replace: Highlight GetSheHe",
    "command": "reg_replace",
    "args": {
        "replacements": ["highlight_getshehe"],
        "action": "mark",
        "options": {"key": "name", "scope": "invalid", "style": "underline"}
    }
}

In reg_relace_rules.sublime_settings:

    "highlight_getshehe":
    {
        "scope": "meta.block.french.csv",
        "literal": true,
        "find": "GetSheHe",
        "greedy": true,
        "replace": ""
    }

My issue is with scope parameter. If i add it, it highlights all the scope when GetSheHe exists. If i remove it, it highlights any GetSheHe in the file. How can I do for highlighting all GetSheHe only in this scope ?
I don’t understand how scope_filter works, maybe it is the solution…

And, is there a parameter for having the mark symbol (a white circle) at the beginning of the line when finding a match ? I tested mark, but no avail. Apparently, it works exactly like underline.

**facelessuser** · March 4, 2017, 2:31pm

@Carpenter, unfortunately, you haven’t provided me with enough info. Please provide example text, and the syntax package you are using to highlight your file.

**Carpenter** · March 4, 2017, 3:22pm

@facelessuser

4 files:

syntax
setting
theme
example: there are 10 GetSheHe in this line. I would like highlight with your plugin #3 #4 #5 #6 because they are in French column (between the second and the third semicolon).

Thank you

**facelessuser** · March 4, 2017, 3:53pm

I will take a look later today. In the future, please create issues in the repo’s issue tracker. I prefer to answer issues there as I then have a issue to reference when people have similar issues.

**facelessuser** · March 4, 2017, 10:20pm

Short answer is that this is due to the way replace is done internally with scope replace. RegReplace will actually replace the entire scope with all your matches replaced proper, which is why it highlights the entire scope. It doesn’t return individual regions for each replace of a scope find. So I am actually getting a region returned for the entire scope instead of individual regions. I would have to refactor the code to possibly preform a different kind of search on the scope buffer that gives me individual regions and replace buffers. While this isn’t a bug per se, I understand that individual regions would be the preferred result.

On a side note, I did find an unrelated bug. If I disable literal, the command fails. Looks like I was trying to recompile an already compiled pattern when doing non-literal scope replacements . I’ll at least have that bug fixed in the next version.

As for the highlight resolution of scope searches, I’ll have to look into a different way of parsing scope buffers to return regions for each individual replace. I don’t know when I’ll have this work completed, but I will probably rush a bug fix to get the more critical bug listed above.

**facelessuser** · March 5, 2017, 4:59pm

For anyone else that sees the recent posts and is confused. RegReplace has two kinds of searches.

Regex searches with scope qualifiers: a regex search that then applies a scope filter on the result to determine if it is valid.
Scope search with regex qualifiers: a search for specific scopes that then applies a regex to it to determine if the scope is a valid result.

So RegReplace when highlighting scope replacements treats the whole scope as a valid result if it contains a regular expression match. It is the opposite of “regex searches with scope qualifiers” which is doing individual regex searches and then applying a scope check to it.

The request by @Carpenter is to have finer resolution and show the regex matches within the scope search. Highlighting the whole scope in a scope rule is not a bug, just the current behavior.

In the future I plan on looking into giving scope search results in finer resolution, but this is low priority. Instead of just sending a scope through subn, we would now have to treat each scope as a separate buffer and iterate over the matches within the scope treating each match individually. This will add more complexity and require a refactoring of the current approach. Hopefully that makes this a bit more clear.

**facelessuser** · March 5, 2017, 5:29pm

RegReplace 3.2.1

Released Mar 5, 2017

FIX: Fix issue where scope search pattern could fail due to recompiling a compiled pattern.

This should fix issue where RegReplace attempts to recompile a compiled pattern in certain scope replacements.

**facelessuser** · May 31, 2017, 7:18pm

Though a new release is out, there is nothing notable about it, but I did package the latest 3rd party regular expression module regex and released it. So run Satisfy Dependencies to get it if you use it or have a passing interest in using it. If you are using re and that’s your favorite, then you can ignore this.

This time I built both the 32 and 64 bit linux binaries on Docker images with a super old CentOS 5, so if it didn’t run on some Linux systems, hopefully now it will. Windows is directly from the wheel, so it should run on all windows systems. Lastly OSX was built on my current mac, so hopefully it works with most macs, who knows.

**facelessuser** · June 5, 2017, 12:51am

3.4.0 is out. Notable change is that scope searches now highlights the find results proper instead of highlighting the whole parent scope. The same goes for other actions like fold, mark, select, etc.

I know this has bugged people for a long time, but I finally got around to making the change.

As always, let me know if I broke something along the way.

**facelessuser** · June 16, 2017, 3:09am

I don’t normally announce every time I update dependencies, but this should be the last time. Regex has been updated to: Update to regex-2017.06.07 (2.4.124). I only mention it because now I build the OSX binaries on a Snow Leopard VM. Since it is so old, it should maximize compatibility on most OSX systems.

**facelessuser** · September 30, 2017, 5:05pm

3.6.0 is out.

This adds support for the Regex library’s format replace template (particularly useful for indexing captures in a group as the Regex library actually retains multiple captures in groups):

>>> regex.subf(r"(\w)+ (\w+)", "{0} => {2} {1[0]}", "foo bar")
'foo bar => bar f'

This can also be used with Backrefs (which requires version 2.1, so ensure dependencies are the latest). Also backrefs includes bug fixes and such, so it is good to pick it up regardless of whether you wish to use the new format feature.

This functionality is also available for Re, but is obviously limited to only one capture as Re only retains the last capture of a group. But if you like the syntax, it is available.

Anyways, you can read more and see more examples about the format replace in Backrefs docs: http://facelessuser.github.io/backrefs/#format-replacements. I’d link to Regex’s documentation, but format replace is only covered in passing.

Big thing to note, as always, read the documentation and links to the various libraries you are using. Recognized syntax, or handling of escaped characters can differ slightly depending on which regular expression engine you are using and whether you have extended_back_references (Backrefs) enabled. For instance, Regex’s format style (without Backrefs) will not translate \\n to a newline like normal replace templates do, it requires a literal new line \n. Format templates with Backrefs will handle \\n like they are in normal replace templates.

Remember to report bugs if you find them. I’ll probably be updating the Regex dependencies to the latest sometime soon to pick up any recent bug fixes.

RegReplace Plugin

RegReplace 3.2.1