I’ve added an option to pad to the right side of the selected character. This preserves the character’s position and instead aligns the non-space text to the right of the character. The default pads to the left side, so the character itself gets aligned.
A complementary set of scripts, align_text_right.py and align_text_right_1.py, use this new option. Here’s the complete set of scripts.
align_text.py:
#------------------------------------------------------------------------
# If the character specified in the current selection is a white space,
# then prompt the user to enter the alignment character (or characters),
# using this character as the initial default.
#------------------------------------------------------------------------
default_align_char = ','
from enum import Enum
class PaddingSide(Enum):
LEFT = 0
RIGHT = 1
def align_selected_text(max_align_char_count = None,
padding_side = PaddingSide.LEFT):
"""Insert padding into the lines in the selection, as needed, to align up to max_align_char_count instances of a specific character or string of characters
The default is to align all instances of the specific character.
At present, the alignment character is taken as the character at the top of
the current selection. You can uncomment some code below to change this
policy to instead take the alignment character from within the selection at
whichever end has the cursor. Either way, if that character is white space,
the user is prompted to type the character (or characters). If you really
wish to align on a white space character, you can just click OK at the
prompt.
When prompted to type the alignment character, the user may enter a
sequence of characters, e.g., "-->", in which case the alignment is on the
instances of that entire character sequence. For example, if the user
enters "-->" at the prompt, then instances of the "-" character get
aligned only if they're followed immediately by the characters "->", while
instances of, say, "-1" and "- " remain unaltered.
If there is no current selection, then aligns all lines in the editor.
If there is a current selection, then aligns only the lines that are
at least partially included in the selection, and the selection is
changed to the entire block of newly-padded lines.
Parameters
----------
max_align_char_count : positive integer, optional
The maximum number of instances to align of the specific
character. For example, set to 1 to align only the first
instance of the character on each line. The default is to
align all instances of the specific character.
padding_side : instance of PaddingSide, optional
Indicates which side of the character gets the padding. The
default is PaddingSide.LEFT, so the character itself gets aligned.
Set to PaddingSide.RIGHT to preserve the character's position and
instead align the non-space text to the right of the character.
"""
from Npp import editor
#----------------------------------------------------------------------------
# For the alignment character, take the character just inside the bounds of
# the selection block (at either the start or the end, as determined below).
#----------------------------------------------------------------------------
editor.targetFromSelection()
selected_text = editor.getTargetText()
#----------------------------------------------------------------------------
# Use this code to get the align_char unconditionally from the start
# of the selection. If there is no selection, use the character at the
# current cursor position; if that is unavailable, fall through to the
# prompt below by treating the alignment character as whitespace.
#----------------------------------------------------------------------------
if selected_text:
align_char = selected_text[0]
else:
current_pos = editor.getCurrentPos()
align_char = editor.getTextRangeFull(current_pos, current_pos + 1)
if not align_char:
align_char = ' '
#----------------------------------------------------------------------------
# Optionally use this code to get the align_char from within the selection
# at whichever end has the cursor.
#----------------------------------------------------------------------------
# if selected_text:
# (startByte, endByte) = editor.getUserCharSelection()
# if startByte == editor.getCurrentPos():
# align_char = selected_text[0]
# else:
# align_char = selected_text[-1]
# else:
# current_pos = editor.getCurrentPos()
# align_char = editor.getTextRangeFull(current_pos, current_pos + 1)
# if not align_char:
# align_char = ' '
# If the character from the selection seems implausible as the
# align_char, then prompt the user for it.
if align_char.isspace():
from Npp import notepad
global default_align_char
align_char = notepad.prompt('Align character:',
'Enter Alignment Character',
default_align_char)
if align_char is not None:
default_align_char = align_char
#----------------------------------------------------------------------------
#%% Get the lines of text within the selected alignment block
#----------------------------------------------------------------------------
(startLine, endLine) = editor.getUserLineSelection()
startPos = editor.positionFromLine(startLine)
endPos = editor.getLineEndPosition(endLine)
text_lines = editor.getTextRangeFull(startPos, endPos).splitlines(True)
#----------------------------------------------------------------------------
# Remember whether there is a user-selected block, so we can restore a
# corresponding selection after aligning the text.
#----------------------------------------------------------------------------
restore_selection = editor.getSelectionStart() != editor.getSelectionEnd()
#----------------------------------------------------------------------------
# Align all instances of align_char within the lines of text
#----------------------------------------------------------------------------
if align_char is not None:
# Enable the following to save the align_char, however it was determined,
# to be the default_align_char when prompting for it next time.
# default_align_char = align_char
if max_align_char_count is None:
align_char_count = max(line.count(align_char) for line in text_lines)
else:
align_char_count = max_align_char_count
start = 0
for instance in range(align_char_count):
# Set the target column using the index of the align_char, ignoring
# immediately preceding space, or the length of the line
align_char_cols = [line.find(align_char, start) for line in text_lines]
# Only lines that contain this instance participate in this pass.
# A failed find() returns -1, and using that as a slice index would
# make lines without this instance incorrectly affect the target.
lines_with_instance = [(line, col)
for (line, col) in zip(text_lines, align_char_cols)
if col >= 0]
if not lines_with_instance:
break
if padding_side == PaddingSide.LEFT:
# Align the alignment character itself, removing any spaces
# immediately to its left before inserting the required padding.
target_col = max(len(line[:col].rstrip())
for (line, col) in lines_with_instance)
for (idx, line) in enumerate(text_lines):
align_char_col = align_char_cols[idx]
if align_char_col >= 0:
text_lines[idx] = line[:align_char_col].rstrip().ljust(target_col) \
+ line[align_char_col:]
start = target_col + len(align_char)
elif padding_side == PaddingSide.RIGHT:
# Align the non-space text after the alignment character.
# Preserve the alignment character itself, but
# replace any existing spaces after it with the required
# padding.
suffix_starts = []
for (line, col) in lines_with_instance:
suffix_start = col + len(align_char)
while suffix_start < len(line) and line[suffix_start] == ' ':
suffix_start += 1
suffix_starts.append(suffix_start)
target_col = max(suffix_starts)
for (idx, line) in enumerate(text_lines):
align_char_col = align_char_cols[idx]
if align_char_col >= 0:
suffix_start = align_char_col + len(align_char)
while suffix_start < len(line) and line[suffix_start] == ' ':
suffix_start += 1
text_lines[idx] = line[:align_char_col + len(align_char)].ljust(target_col) \
+ line[suffix_start:]
start = target_col
else:
raise ValueError('Unsupported padding_side: {}'.format(padding_side))
editor.setTarget(startPos, endPos)
editor.replaceTarget(''.join(text_lines))
if restore_selection:
startPos = editor.positionFromLine(startLine)
endPos = editor.getLineEndPosition(endLine)
editor.setSelectionStart(startPos)
editor.setSelectionEnd(endPos)
if __name__ == '__main__':
align_selected_text()
align_text_1.py:
from align_text import align_selected_text
align_selected_text(max_align_char_count = 1)
align_text_right.py:
from align_text import align_selected_text, PaddingSide
align_selected_text(padding_side = PaddingSide.RIGHT)
align_text_right_1.py:
from align_text import align_selected_text, PaddingSide
align_selected_text(max_align_char_count = 1,
padding_side = PaddingSide.RIGHT)
