Nano.lua

--[[
nano clone based off GNU nano for OpenComputers
by Gamax92
--]]
local component = require("component")
local computer = require("computer")
local kbd = require("keyboard")
local keys = kbd.keys
local fs = require("filesystem")
local shell = require("shell")
local event = require("event")
local term = require("term")
local unicode = require("unicode")

local nanoVERSION = "1.0.0"

local function printf(...) print(string.format(...)) end
local function eprintf(...) io.stderr:write(string.format(...) .. "\n") end
local event_pull = term.pull or event.pull
-- Fix keys.none
keys["none"] = 0
keys[0] = "none"

-- TODO: Replace with more gnuopt style parser
local args, opts = shell.parse(...)

-- TODO: Once above has been done, check for invalid arguments
-- Default options
local options = {
	fgcolor = 0xFFFFFF,
	bgcolor = 0x000000,
	tabsize = 8,
}
local flags={"autoindent","backup","backwards","brighttext","casesensitive","const","cut","morespace","mouse","multibuffer","noconvert","nohelp","nonewlines","nowrap","quiet","quickblank","patterns","smarthome","smooth","softwrap","tabstospaces","tempfile","undo","view"}
for i = 1,#flags do
	options[flags[i]] = false
end
-- TODO: HACK, REMOVE WHEN HELP AREA IS IMPLEMENTED
options.nohelp = true
flags = nil
-- Default bindings
-- TODO: Bindings for things other than main
local bind = {
	main = {
		{"help","^G","F1"},
		{"exit","^X","F2"},
		{"writeout","^O","F3"},
		{"insert","^R","F5","insert"},
		{"whereis","^W","F6"},
		{"replace","^\\","M-R","F14"},
		{"cut","^K","F9"},
		{"uncut","^U","F10"},
		{"justify","^J","F4"},
		{"speller","^T","F12"},
		{"curpos","^C","F11"},
		{"gotoline","^_","M-G","F13"},
		{"prevpage","^Y","F7","pageUp"},
		{"nextpage","^V","F8","pageDown"},
		{"firstline","M-\\","M-|"},
		{"lastline","M-/","M-?"},
		{"searchagain","M-W","F16"},
		{"findbracket","M-]"},
		{"mark","^^","M-A","F15"},
		{"copytext","M-^","M-6"},
		{"indent","M-}"},
		{"unindent","M-{"},
		{"undo","M-U"},
		{"redo","M-E"},
		{"left","^B","left"},
		{"right","^F","right"},
		{"prevword","M-Space"},
		{"nextword","^Space"},
		{"home","^A","home"},
		{"end","^E","end"},
		{"prevline","^P","up"},
		{"nextline","^N","down"},
		{"beginpara","M-(","M-9"},
		{"endpara","M-)","M-0"},
		{"scrollup","M--","M-_"},
		{"scrolldown","M-+","M-="},
		{"prevbuf","M-<","M-,"},
		{"nextbuf","M->","M-."},
		{"verbatim","M-V"},
		{"tab","^I"},
		{"enter","^M","enter"},
		{"delete","^D","delete"},
		{"backspace","^H","back"},
		{"cutrestoffile","M-T"},
		{"fulljustify","M-J"},
		{"wordcount","M-D"},
		{"refresh","^L"},
		{"suspend","^Z"},
		{"nohelp","M-X"},
		{"constupdate","M-C"},
		{"morespace","M-O"},
		{"smoothscroll","M-S"},
		{"softwrap","M-$"},
		{"whitespacedisplay","M-P"},
		{"nosyntax","M-Y"},
		{"smarthome","M-H"},
		{"autoindent","M-I"},
		{"cuttoend","M-K"},
		{"nowrap","M-L"},
		{"tabstospaces","M-Q"},
		{"backupfile","M-B"},
		{"multibuffer","M-F"},
		{"mouse","M-M"},
		{"noconvert","M-N"},
		{"suspendenable","M-Z"},
	}
}
local vfn = {}
for k,v in pairs(bind) do
	for i = 1,#v do
		local b = v[i]
		for j = 2,#b do
			v[unicode.upper(b[j])]=b[1]
		end
		vfn[b[1]]=true
		v[i] = nil
	end
end

local function parseRC(filename)
	local problem = false
	local i = 1
	local function bad(msg, ...)
		problem = true
		printf("Error in %s on line %d: " .. msg, filename, i, ...)
	end
	local file, err = io.open(filename,"rb")
	if not file then
		problem = true; printf("Error reading %s: %s", filename, err)
	else
		for line in file:lines() do
			local cmd = {}
			for part in line:gmatch("%S+") do
				cmd[#cmd+1] = part
			end
			if cmd[1] == "set" or cmd[1] == "unset" then
				if #cmd < 2 then
					bad("Missing flag")
				elseif options[cmd[2]] ~= nil then
					if type(options[cmd[2]]) == "boolean" then
						options[cmd[2]] = cmd[1] == "set"
					elseif cmd[1] == "unset" then
						bad("Cannot unset option \"%s\"", cmd[2])
					elseif type(options[cmd[2]]) == "number" then
						if tonumber(cmd[3]) == nil then
							bad("Parameter \"%s\" is invalid", cmd[3])
						else
							options[cmd[2]] = tonumber(cmd[3])
						end
					end
				else
					bad("Unknown flag \"%s\"", cmd[2])
				end
			elseif cmd[1] == "bind" or cmd[1] == "unbind" then
				if cmd[2] == nil then
					bad("Missing key name")
				else
					local first = unicode.upper(cmd[2]:sub(1,1))
					local last = cmd[1] == "bind" and cmd[4] or cmd[3]
					if first ~= "^" and first ~= "M" and first ~= "F" then
						bad("Key name must begin with \"^\", \"M\", or \"F\"")
					elseif cmd[1] == "bind" and cmd[3] == nil then
						bad("Must specify a function to bind the key to")
					elseif last == nil then
						bad("Must specify a menu (or \"all\") in which to bind/unbind the key")
					elseif cmd[1] == "bind" and not vfn[cmd[3]] then
						bad("Cannot map name \"%s\" to a function", cmd[3])
					elseif bind[last] == nil then
						bad("Cannot map name \"%s\" to a menu", last)
					else
						if cmd[1] == "bind" then
							bind[last][cmd[2]] = cmd[3]
						elseif cmd[1] == "unbind" then
							bind[last][cmd[2]] = nil
						end
					end
				end
			else
				bad("Command \"%s\" not understood", cmd[1])
			end
			i = i + 1
		end
	end
	if problem then
		print("Press Enter to continue starting nano.")
		while true do
			local name,_,_,code = event_pull()
			if name == "key_down" and code == keys.enter then break end
		end
	end
end
if fs.exists("/etc/nanorc") then
	parseRC("/etc/nanorc")
end
-- TODO: Parse arguments

local buffers, buffer = {}
local gpu = component.gpu
gpu.setForeground(options.fgcolor)
gpu.setBackground(options.bgcolor)
local gpuW, gpuH = gpu.getResolution()
gpu.fill(1,1,gpuW,gpuH," ")
term.setCursorBlink(true)

-- TODO: more modes
local mode = "main"
-- Calculate positions for screen elements
local linesY = (options.morespace and 2 or 3)
local linesH = gpuH - linesY
local statusbarY = gpuH
if not options.nohelp then
	linesH = linesH - 2
	statusbarY = statusbarY - 2
end
-- TODO: Help lines


local utf8char = "[%z\1-\127\194-\244][\128-\191]*"
local function formatLine(text,map)
	local newstr, pos = {}, 0
	local cmap
	if map then
		cmap = {}
	end
	for char in text:gmatch(utf8char) do
		if map then
			cmap[#cmap+1] = pos+1
		end
		if char == "\t" then
			local amt = options.tabsize - pos%options.tabsize
			for i = 1,amt do
				newstr[#newstr+1] = " "
			end
			pos = pos + amt
		else
			newstr[#newstr+1] = char
			pos = pos + unicode.charWidth(char)
		end
	end
	if map then
		cmap[#cmap+1] = pos+1
	end
	return table.concat(newstr), cmap
end

local function setTitleBar(buffer)
	local title = " New Buffer "
	if buffer.filename ~= nil then
		title = " File: " .. buffer.filename:match(".*/(.+)") .. " "
	end
	gpu.setForeground(options.bgcolor)
	gpu.setBackground(options.fgcolor)
	gpu.fill(1,1,gpuW,1," ")
	local startX = (gpuW - unicode.wlen(title))/2
	gpu.set(3,1,"Lua nano " .. nanoVERSION)
	if buffer.modified then
		local str = "Modified"
		gpu.set(gpuW-unicode.wlen(str)-2,1,str)
	end
	gpu.set(startX,1,title)
	gpu.setForeground(options.fgcolor)
	gpu.setBackground(options.bgcolor)
end

local function setModified(buffer,mod)
	if mod == nil then mod = true end
	if buffer.modified ~= mod then
		buffer.modified = mod
		setTitleBar(buffer)
	end
end

local timeout = math.huge
local function setStatusBar(text)
	timeout = 0
	text = "[ " .. text .. " ]"
	gpu.fill(1,statusbarY,gpuW,1," ")
	gpu.setForeground(options.bgcolor)
	gpu.setBackground(options.fgcolor)
	local startX = (gpuW - unicode.wlen(text))/2
	gpu.set(startX,statusbarY,text)
	gpu.setForeground(options.fgcolor)
	gpu.setBackground(options.bgcolor)
end

local function createNewBuffer()
	return {
		filename=nil,
		modified=false,
		lines = {
		},
		x = 1,
		tx = 1,
		y = 1,
		startLine = 1,
	}
end

local function createBuffer(filename)
	local buffer = createNewBuffer()
	if fs.exists(filename) then
		local file, err = io.open(filename,"rb")
		if file then
			buffer.filename = filename
			for line in file:lines() do
				buffer.lines[#buffer.lines+1] = line
			end
			file:close()
			setStatusBar("Read " .. #buffer.lines .. " line" .. (#buffer.lines ~= 1 and "s" or ""))
		else
			setStatusBar("Couldn't open " .. filename .. ": " .. err)
		end
	else
		buffer.filename = filename
	end
	if #buffer.lines == 0 then
		buffer.lines[1] = ""
	end
	buffers[#buffers+1] = buffer
end

local function drawLine(line,y)
	local fline = formatLine(line)
	if unicode.wlen(fline) < gpuW then
		fline = fline .. string.rep(" ",gpuW - unicode.wlen(fline))
	elseif unicode.wlen(fline) > gpuW then
		fline = unicode.wtrunc(fline,gpuW)
		fline = fline .. string.rep(" ",gpuW - unicode.wlen(fline) - 1) .. "$"
	end
	gpu.set(1,y,fline)
end

local function updateActiveLine(simple)
	local line = buffer.lines[buffer.y]
	term.setCursorBlink(false)
	if not simple then
		local fline,map = formatLine(line,true)
		-- TODO: This is not nano style line clamping, plus it messes up when tabs have things behind them
		local xwant = map[math.min(buffer.x,#map)]
		local gwant = math.floor(gpuW*3/4)
		if unicode.wlen(fline) >= gpuW and xwant >= gwant then
			for i = 2,#map do
				if xwant-map[i]+1 < gwant then
					line = unicode.sub(line,i)
					xwant = xwant-map[i]+1
					break
				end
			end
		end
		term.setCursor(xwant,buffer.y-buffer.startLine+linesY)
	end
	drawLine(line,buffer.y-buffer.startLine+linesY)
	for i=1,2 do term.setCursorBlink(true)end
end

local function updateTX()
	local _,map = formatLine(buffer.lines[buffer.y],true)
	buffer.tx = map[math.min(buffer.x,#map)]
end

local function scrollBuffer()
	local amt
	local startLine = buffer.startLine
	if buffer.y-startLine < 0 then
		amt = buffer.y-startLine
	elseif buffer.y-startLine > (linesH-1) then
		amt = buffer.y-startLine-(linesH-1)
	end
	if not amt then return end
	term.setCursorBlink(false)
	startLine = startLine + amt
	buffer.startLine = startLine
	if amt > 0 then
		gpu.copy(1,linesY+amt,gpuW,linesH-amt,0,-amt)
		for i = startLine+linesH-1-amt, math.min(startLine+linesH-1,#buffer.lines) do
			drawLine(buffer.lines[i],i-startLine+linesY)
		end
	else
		gpu.copy(1,linesY,gpuW,linesH+amt,0,-amt)
		for i = startLine, math.min(startLine-amt-1,#buffer.lines) do
			drawLine(buffer.lines[i],i-startLine+linesY)
		end
	end
	term.setCursorBlink(true)
end

local function redraw()
	setTitleBar(buffer)
	-- TODO: Only clear the area lacking lines
	gpu.fill(1,linesY,gpuW,linesH," ")
	local startLine, amt = buffer.startLine
	if buffer.y-startLine < 0 then
		amt = buffer.y-startLine
	elseif buffer.y-startLine > (linesH-1) then
		amt = buffer.y-startLine-(linesH-1)
	end
	if amt then
		startLine = startLine + amt
		buffer.startLine = startLine
	end
	for i = startLine, math.min(startLine+linesH-1,#buffer.lines) do
		drawLine(buffer.lines[i],i-startLine+linesY)
	end
	updateActiveLine()
end

local function switchBuffers(index)
	buffer = buffers[index]
	if buffers.cur ~= nil then
		local name = "New Buffer"
		if buffer.filename ~= nil then
			name = buffer.filename:match(".*/(.+)")
		end
		setStatusBar("Switched to " .. name)
	end
	buffers.cur = index
	redraw()
end

local function statusPrompt(text)
	gpu.fill(1,statusbarY,gpuW,1," ")
	gpu.set(1,statusbarY,text)
	term.setCursor(unicode.wlen(text)+1,statusbarY)
end

local function resetColor()
	gpu.setForeground(options.fgcolor)
	gpu.setBackground(options.bgcolor)
end

local running = true
local function clul() return unicode.len(buffer.lines[buffer.y]) end
local binding = {}
function binding.exit()
	-- TODO: Get a MYESNO mode
	if buffer.modified then
		gpu.setForeground(options.bgcolor)
		gpu.setBackground(options.fgcolor)
		statusPrompt("Save modified buffer (ANSWERING \"No\" WILL DESTROY CHANGES) ? ")
		while true do
			local e,_,c = event_pull()
			if e == "key_down" then
				c = unicode.lower(unicode.char(c))
				local ctrl = kbd.isControlDown()
				if not ctrl and c == "y" then
					-- TODO: Get a MWRITEFILE mode
					-- TODO: Needs more options
					local oldname = ""
					if buffer.filename ~= nil then
						oldname = buffer.filename:match(".*/(.+)")
					end
					local filename = oldname
					::tryagain::
					statusPrompt("File Name to Write: ")
					-- TODO: HACK HACK HACK
					computer.pushSignal("key_down",computer.address(),0,keys.up)
					filename = term.read({filename},false)
					if filename then
						filename = filename:gsub("[\r\n]","")
					end
					if filename == "" or filename == nil then
						resetColor()
						setStatusBar("Cancelled")
						return
					end
					if filename ~= oldname and fs.exists(shell.resolve(filename)) then
						-- TODO: Again, MYESNO mode
						statusPrompt("File exists, OVERWRITE ? ")
						while true do
							local e,_,c = event_pull()
							c = unicode.lower(unicode.char(c))
							if e == "key_down" then
								local ctrl = kbd.isControlDown()
								if not ctrl and c == "y" then
									break
								elseif (not ctrl and c == "n") or (ctrl and c == "\3") then
									goto tryagain
								end
							end
						end
					end
					local file, err = io.open(shell.resolve(filename),"wb")
					if not file then
						resetColor()
						setStatusBar("Error writing " .. filename .. ": " .. err)
						return
					end
					for i = 1,#buffer.lines do
						file:write(buffer.lines[i] .. "\n")
					end
					file:close()
					break
				elseif not ctrl and c == "n" then
					break
				elseif ctrl and c == "\3" then
					resetColor()
					setStatusBar("Cancelled")
					return
				end
			end
		end
	end
	gpu.setForeground(options.fgcolor)
	gpu.setBackground(options.bgcolor)
	table.remove(buffers,buffers.cur)
	buffers.cur = math.min(buffers.cur,#buffers)
	if buffers.cur < 1 then
		running = false
	else
		switchBuffers(buffers.cur)
	end
end
function binding.left()
	if buffer.x > 1 or buffer.y > 1 then
		buffer.x = buffer.x - 1
		if buffer.x < 1 then
			updateActiveLine(true)
			buffer.y = buffer.y - 1
			buffer.x = unicode.len(buffer.lines[buffer.y])+1
			scrollBuffer()
		end
		updateTX()
		updateActiveLine()
	end
end
function binding.right()
	if buffer.x < clul()+1 or buffer.y < #buffer.lines then
		buffer.x = buffer.x + 1
		if buffer.x > clul()+1 then
			updateActiveLine(true)
			buffer.y = buffer.y + 1
			buffer.x = 1
			scrollBuffer()
		end
		updateTX()
		updateActiveLine()
	end
end
function binding.prevline()
	if buffer.y > 1 then
		updateActiveLine(true)
		buffer.y = buffer.y - 1
		local _,map = formatLine(buffer.lines[buffer.y],true)
		for i = 1,#map do
			if map[i] > buffer.tx then break end
			buffer.x = i
		end
		scrollBuffer()
		updateActiveLine()
	end
end
function binding.nextline()
	if buffer.y < #buffer.lines then
		updateActiveLine(true)
		buffer.y = buffer.y + 1
		local _,map = formatLine(buffer.lines[buffer.y],true)
		for i = 1,#map do
			if map[i] > buffer.tx then break end
			buffer.x = i
		end
		scrollBuffer()
		updateActiveLine()
	end
end
function binding.prevpage()
	if buffer.y > 1 then
		local diff = math.max(buffer.y - linesH, 1) - buffer.y
		buffer.y = buffer.y + diff
		buffer.startLine = math.max(buffer.startLine + diff, 1)
		local _,map = formatLine(buffer.lines[buffer.y],true)
		for i = 1,#map do
			if map[i] > buffer.tx then break end
			buffer.x = i
		end
		redraw()
	end
end
function binding.nextpage()
	if buffer.y < #buffer.lines then
		local diff = math.min(buffer.y + linesH, #buffer.lines) - buffer.y
		buffer.y = buffer.y + diff
		buffer.startLine = math.min(buffer.startLine + diff, #buffer.lines-linesH+1)
		local _,map = formatLine(buffer.lines[buffer.y],true)
		for i = 1,#map do
			if map[i] > buffer.tx then break end
			buffer.x = i
		end
		redraw()
	end
end
function binding.home()
	if buffer.x > 1 then
		buffer.x = 1
		updateTX()
		updateActiveLine()
	end
end
binding["end"] = function()
	if buffer.x < clul()+1 then
		buffer.x = clul()+1
		updateTX()
		updateActiveLine()
	end
end
function binding.backspace()
	if buffer.x == 1 then
		if buffer.y > 1 then
			setModified(buffer)
			buffer.x = unicode.len(buffer.lines[buffer.y-1])+1
			buffer.lines[buffer.y-1] = buffer.lines[buffer.y-1] .. buffer.lines[buffer.y]
			table.remove(buffer.lines,buffer.y)
			buffer.y = buffer.y - 1
			-- TODO: Don't redraw everything
			redraw()
		end
	else
		setModified(buffer)
		local line = buffer.lines[buffer.y]
		buffer.lines[buffer.y] = unicode.sub(line,1,buffer.x-2) .. unicode.sub(line,buffer.x)
		buffer.x = buffer.x - 1
		updateActiveLine()
	end
	updateTX()
end
function binding.delete()
	if buffer.x >= clul()+1 then
		setModified(buffer)
		if buffer.y < #buffer.lines then
			buffer.lines[buffer.y] = buffer.lines[buffer.y] .. buffer.lines[buffer.y+1]
			table.remove(buffer.lines,buffer.y+1)
			-- TODO: Don't redraw everything
			redraw()
		end
	else
		setModified(buffer)
		local line = buffer.lines[buffer.y]
		buffer.lines[buffer.y] = unicode.sub(line,1,buffer.x-1) .. unicode.sub(line,buffer.x+1)
		updateActiveLine()
	end
end
function binding.enter()
	setModified(buffer)
	local line = buffer.lines[buffer.y]
	table.insert(buffer.lines,buffer.y+1,unicode.sub(line,buffer.x))
	buffer.lines[buffer.y] = unicode.sub(line,1,buffer.x-1)
	buffer.x = 1
	buffer.tx = 1
	buffer.y = buffer.y + 1
	-- TODO: Don't redraw everything
	redraw()
end
function binding.prevbuf()
	buffers.cur = ((buffers.cur-2)%#buffers)+1
	switchBuffers(buffers.cur)
end
function binding.nextbuf()
	buffers.cur = (buffers.cur%#buffers)+1
	switchBuffers(buffers.cur)
end
function binding.curpos()
	-- TODO: Character count
	local la,lb = buffer.y,#buffer.lines
	local oa,ob = buffer.x,#buffer.lines[buffer.y]+1
	local cb = 0
	for i = 1,buffer.y-1 do
		cb = cb + #buffer.lines[i]+1
	end
	local ca = cb + buffer.x
	for i = buffer.y,#buffer.lines do
		cb = cb + #buffer.lines[i]+1
	end
	setStatusBar(string.format("line %d/%d (%d%%), col %d/%d (%d%%), char %d/%d (%d%%)",la,lb,la/lb*100+0.5, oa,ob,oa/ob*100+0.5, ca,cb,ca/cb*100+0.5))
end

-- TODO: Line and column arguments
-- Load files
if #args > 0 then
	for i = 1,#args do
		createBuffer(shell.resolve(args[i]))
	end
	if #buffers > 1 then
		setStatusBar("Read " .. #buffers[1].lines .. " line" .. (#buffers[1].lines ~= 1 and "s" or ""))
	end
else
	local buffer = createNewBuffer()
	buffer.lines[1] = ""
	buffers[#buffers+1] = buffer
end

-- Show the first file
switchBuffers(1)

while running do
	local e = { event_pull() }
	if e[1] == "key_down" then
		local char, code = e[3], e[4]
		local ctrl = kbd.isControlDown()
		local alt = kbd.isAltDown()
		local scp,sc = keys[code]:sub(1,1), keys[code]:sub(2)
		local schar
		if not kbd.isControl(char) and char ~= 32 then
			schar = unicode.upper(unicode.char(char))
		else
			schar = unicode.upper(keys[code])
		end
		if ctrl then
			-- TODO: This doesn't cover everything
			if unicode.len(keys[code]) == 1 then
				schar = unicode.upper(keys[code])
			end
		end
		if ctrl then
			schar = "^" .. schar
		elseif alt then
			schar = "M-" .. schar
		end
		if (scp == "l" or scp == "r") and (sc == "control" or sc == "menu" or sc == "shift") then
		elseif bind[mode][schar] ~= nil then
			local cmd = bind[mode][schar]
			if binding[cmd] ~= nil then
				binding[cmd]()
			else
				setStatusBar("Binding \"" .. cmd .. "\" Unimplemented")
			end
		elseif ctrl or alt then
			setStatusBar("Unknown Command")
		elseif not kbd.isControl(char) or char == 9 then
			timeout = timeout + 1
			if timeout >= (options.quickblank and 1 or 25) then
				gpu.fill(1,statusbarY,gpuW,1," ")
			end
			setModified(buffer)
			local line = buffer.lines[buffer.y]
			buffer.lines[buffer.y] = unicode.sub(line,1,buffer.x-1) .. unicode.char(char) .. unicode.sub(line,buffer.x)
			buffer.x = buffer.x + 1
			updateTX()
			updateActiveLine()
		end
	end
end

term.clear()
term.setCursorBlink(false)

-- Unfix keys.none
keys["none"] = nil
keys[0] = nil