Text Block Rewrap Module

[eric1234]

Something I missed from previous editors was a hotkey to rewrap text. Most of the time I want to limit the line width to 80 characters because long lines are hard to read (and it's even more annoying at the terminal). This means I'm usually inserting a line break every 80ish characters when writing a block of text.

The problem is if you go back and edit that block of text where the first line is already near 80 and add more content you end up moving some of the text to the next line which makes it too long so you have to move some of it to the 3rd line, etc usually until you end up at the end of the text block. That's a lot of editing.

A rewrap hot key allows you to select the paragraph after you get done adding your content, press Ctrl-Q and it will automatically figure out where to add the line breaks. Even more important is the same thing in code comments. Only here each line has some sort of prefix to indicate the line is a comment and indention. Once re-wrapped we want to to preserve that indention and still prefix each line with the comment indicator.

The below module is my first crack at implementing this. Still fairly new so I'm sure there are bugs but figured I would go ahead and share in case anybody else wants to use:

M = {}

-- Putting some generic functions in the global space as we might eventually
-- use them in other modules and therefore move them to the global utilities.
-- Basically any methods that would be part of the stdlib for a full featured
-- language.

-- Assumes an array-like table. Returns a new array mapping value via callback
function table.map(list, callback)
  local ret = {}
  for _, item in ipairs(list) do
    table.insert(ret, callback(item))
  end
  return ret
end

-- Assuming an array-like table. Removes all items that evaluate to false.
function table.compact(list)
  local ret = {}
  for _, item in ipairs(list) do
    if item then
      table.insert(ret, item)
    end
  end
  return ret
end

-- Extends string to allow splitting via the given pattern
function string.split(content, pattern)
  local list = {}
  for item in content:gmatch(pattern) do
    table.insert(list, item)
  end
  return list
end

-- Extends string to allow splitting by lines. Multiple line breaks are collapsed
-- and can operate on the different line break types (\r, \n, and \r\n).
function string.split_lines(content)
  return content:split("[^\r\n]+")
end

-- Extends string to split by spacing between words.
function string.split_words(content)
  return content:split("[^ ]+")
end

-- Extends string to get a character at a specific location
function string.char_at(str, idx)
  return str:sub(idx, idx)
end

-- Now the stuff truly local to this module

local function modifying_selection(callback)
  -- We rewrap entire lines
  buffer.selection_mode = buffer.SEL_LINES

  local original = buffer:get_sel_text()
  local modified = callback(original)

  -- Conditionally replace to avoid marking the buffer as dirty
  if( original ~= modified ) then buffer:replace_sel(modified) end

  -- Revert back to original selection mode
  buffer:cancel()
end

local function strip_prefix(items, prefix)
  return table.map(items, function(item)
    local stripped = item:gsub('^'..prefix, '')
    return stripped
  end)
end

local function prepend_prefix(items, prefix)
  return table.map(items, function(item)
    return prefix..item
  end)
end

local function extract_prefix(lines)
  local idx = 1
  local prefix = ''
  local mismatch = false

  repeat
    local cur = lines[1]:char_at(idx)

    for _, line in ipairs(lines) do
      if line:char_at(idx) ~= cur then
        mismatch = true
        goto continue
      end
    end

    idx = idx + 1
    prefix = prefix..cur

    ::continue::
  until mismatch

  return strip_prefix(lines, prefix), prefix
end

local function add_word(content, word)
  if #content == 0 then
    return word
  else
    return content..' '..word
  end
end

local function tap(val, callback)
  callback(val)
  return val
end

local function rewrap(width, lines)
  local line = ''
  local words = table.concat(lines, ' '):split_words()
  local rewrapped = table.compact(table.map(words, function(word)
    local test = add_word(line, word)

    if #test > width then
      return tap(line, function() line = word end)
    else
      line = test
      return nil
    end
  end))
  table.insert(rewrapped, line)
  return rewrapped
end

function M.rewrap()
  modifying_selection(function(to_rewrap)
    local orig_lines, prefix = extract_prefix(to_rewrap:split_lines())
    local width = view.edge_column - #prefix
    return table.concat(prepend_prefix(rewrap(width, orig_lines), prefix), "\n")
  end)
end

keys['ctrl+Q'] = M.rewrap

return M

[orbitalquark]

This is nice, but since you're on both Linux and macOS, why not make use the Unix fmt command? My format module uses it: https://github.com/orbitalquark/textadept-format/

[eric1234]

🤦

I had read that module description quick and saw "Code formatting module for Textadept" and just assumed it was only about automatic code formatting (which I am not fan of). I completely missed that is also did a paragraph formatting using the fmt command.

Will give it a whirl and assuming it works well (likely) I probably switch to that since it's more official than my own hacky Lua code. Thanks for the pointer!