A desktop user's guide to Nano, a command-line text editor

[Radishrain]

If you want to know how to do custom operations on selected text in nano, this post is for you:

First of all, make a python script, make it executable, and put it in your path (so it can be called anywhere). If you wish to modify selected text, rather than just print something in nano, you'll need to make the program so you can pipe it in. Call the command like this: ctrl+t; then type `|myCommand myArg1 myArg2` (not counting the backtics, of course). Note that Python scripts don't have to end in `.py` to run.

Python-style regular expression search/replace:

To do regular expression searches with nano, you could try the built-in features, but they won't find or replace new lines.

I prefer Python regular expressions. So, I'm going to tell you how to use those in nano.

Here's the code:

reg.py:

#!/usr/bin/env python3

import re, sys;

text=sys.stdin.read();
reg="";
if len(sys.argv)==3:
    #Usage: ctrl+t; |reg.py "my regex" "my replacement" (don't forget the quotes, or some such); this is the default usage for two arguments.
    reg=sys.argv[1];
    rep=sys.argv[2];
    result=re.sub(reg, rep, text);
elif len(sys.argv)==2: #Usage: ctrl+t; |reg.py "my regex". Using one argument replaces the selected text with the text that matches the regular expression, delimited by new lines (press alt+u to undo this action on nano). The argument must be surrounded in quotes.
    reg=sys.argv[1];
    result="\n".join(re.findall(reg, text));
else:
    result=re.sub(r"", r"", text); #If you have no arguments, you'll need to edit the regular expression here to use it as the default.
print(result);

For doing ascending/descending/shuffle sorts, here is some code for more files (do `pip install natsort` first, if you don't have natsort installed):

This file is needed for the other ones to work:

import natsort, traceback, math, re, random;

"""
See these files to pipe into nano:
asc.py
uasc.py
desc.py
udesc.py
shu.py
ush.py
"""

def sort_chunks(myList):
    #This takes a sorted list, and sorts each chunk of entries that would be the same if they had the same casing (according to the GROUPLETTERS algorithm). The returned list amounts to what GROUPLETTERS|IGNORECASE ought to result in, IMO.
    finds=[];
    previous_x=None;
    for x in myList:
        if len(finds)==0:
            finds.append([x]);
        else:
            if previous_x.lower()==x.lower():
                finds[-1].append(x);
            else:
                finds.append([x]);
        previous_x=x;
    newList=[];
    for x in finds:
        case_sorted=natsort.natsorted(x, alg=natsort.ns.GROUPLETTERS);
        for y in case_sorted:
            newList.append(y);
    return newList;

def sorted_nums(myList, rev=False, cs=False):
    #The name is a misnomer and needs to be changed now that natsort sorts the numbers.
    result=None;
    if cs==True:
        result=natsort.natsorted(myList, alg=natsort.ns.GROUPLETTERS);
    else:
        result=natsort.natsorted(myList, alg=natsort.ns.IGNORECASE);
        try:
            result=sort_chunks(result);
        except:
            traceback.print_exc();
    if rev==True:
        result.reverse();
    return result;

def group_item_split(text):
    split_text=text.split("\n");
    minimal_indent=math.inf;
    for x in split_text:
        found=re.findall(r"^ *", x);
        for y in found:
            if len(y)<minimal_indent:
                minimal_indent=len(y);
    spaces="";
    for x in range(0,minimal_indent):
        spaces+=" ";
    new_list=[];
    i=0;
    new_i=0;
    while i<len(split_text.copy()):
        modified=False;
        if i==0:
            split_text[i]=spaces+split_text[i].lstrip();
        if split_text[i].startswith(spaces+" "):
            new_list[new_i-1]=new_list[new_i-1]+"\n"+split_text[i];
            modified=True;
        else:
            new_list.append(split_text[i]);
        if modified==False:
            new_i+=1;
        i+=1;
    return new_list;


def usplit(text, splitArgs, unique=True, gr=False):
    #Unique split
    #Allows removing duplicates from a split list.
    #if gr is True it will group indented material with its parent line, for when you are sorting lines (instead of sorting each line no matter the indents); this treats splitArgs as if it were "\n"
    tList=None;
    if gr==False:
        if unique==True:
            tList=list(set(text.split(splitArgs)));
        else:
            tList=text.split(splitArgs);
    else:
        if unique==True:
            tList=list(set(group_item_split(text)));
        else:
            tList=group_item_split(text);
    return tList;

def sort_ascending(text, rev=False, gr=True, unique=True):
    if text!="":
        if "\n" in text:
            tList=usplit(text, "\n", unique, gr=gr);
            tList=sorted_nums(tList, rev);
            text="\n".join(tList);
        elif gr==True and (", " in text or "," in text):
            text=re.sub(r", *", r",", text);
            tList=usplit(text, ",", unique);
            tList=sorted_nums(tList, rev);
            text=", ".join(tList);
        elif " " in text:
            text=re.sub(r" +", r" ", text);
            tList=usplit(text, " ", unique);
            tList=sorted_nums(tList, rev);
            text=" ".join(tList);
        else:
            tList=None;
            if unique==True:
                tList=list(set(list(text)));
            else:
                tList=list(text);
            tList.sort(reverse=rev);
            text="".join(tList);
    return text;
            
def sort_descending(text, gr=True, unique=True):
    return sort_ascending(text=text, rev=True, gr=gr, unique=unique);

def shuffle(text, gr=True, unique=True):
    if text!="":
        if "\n" in text:
            tList=usplit(text, "\n", unique, gr=gr);
            random.shuffle(tList);
            text="\n".join(tList);
        elif gr==True and (", " in text or "," in text):
            text=re.sub(r", *", r",", text);
            tList=usplit(text, ",", unique);
            random.shuffle(tList);
            text=", ".join(tList);
        elif " " in text:
            text=re.sub(r" +", r" ", text);
            tList=usplit(text, " ", unique);
            random.shuffle(tList);
            text=" ".join(tList);
        else:
            tList=None;
            if unique==True:
                tList=list(set(list(text)));
            else:
                tList=list(text);
            random.shuffle(tList);
            text="".join(tList);
    return text;

asc.py: (sort ascending; duplicates are not removed)

#!/usr/bin/env python3

#Pipe this into nano to sort selected text in ascending order: ctrl+t; |asc.py

import sortshuffle, sys;

text=sys.stdin.read();

result=sortshuffle.sort_ascending(text, gr=False, unique=False);

print(result);

uasc.py: (sort ascending; duplicates are removed)

#!/usr/bin/env python3

#Pipe this into nano to sort selected text in ascending order: ctrl+t; |uasc.py

import sortshuffle, sys;

text=sys.stdin.read();

result=sortshuffle.sort_ascending(text, gr=False, unique=True);

print(result);

desc.py (sort descending; duplicates are not removed)

#!/usr/bin/env python3

#Pipe this into nano to sort selected text in ascending order: ctrl+t; |desc.py

import sortshuffle, sys;

text=sys.stdin.read();

result=sortshuffle.sort_descending(text, gr=False, unique=False);

print(result);

udesc.py (sort descending; duplicates are removed)

#!/usr/bin/env python3

#Pipe this into nano to sort selected text in ascending order: ctrl+t; |udesc.py

import sortshuffle, sys;

text=sys.stdin.read();

result=sortshuffle.sort_descending(text, gr=False, unique=True);

print(result);

shu.py: (shuffle; duplicates are not removed)

#!/usr/bin/env python3

#Pipe this into nano to sort selected text in ascending order: ctrl+t; |shu.py

import sortshuffle, sys;

text=sys.stdin.read();

result=sortshuffle.shuffle(text, gr=False, unique=False);

print(result);

ush.py (shuffle; duplicates are removed)

#!/usr/bin/env python3

#Pipe this into nano to sort selected text in ascending order: ctrl+t; |ush.py

import sortshuffle, sys;

text=sys.stdin.read();

result=sortshuffle.shuffle(text, gr=False, unique=True);

print(result);

The sort and shuffle functions work differently depending on what you're sorting or shuffling (for instance, if it's a word, it'll sort the characters of the word; if it's multiple words on a line, it'll sort the words; if it's multiple lines, it'll sort the lines; natsort allows numbers to be sorted numerically, rather than alphabetically. If you want indented material to be grouped with the outermost parent line, do `gr=True` in the calling function.

[Radishrain]

To get an immersive experience where you just have words you type and nothing else, do this:

nano -0

or

nano --zero

Pressing alt+x will toggle the stuff at the bottom on and off. I'm not sure how to toggle the stuff at the top on and off without restarting, though.

I make a script to run nano with this:

#!/bin/bash

nano -0 "$@"