2018-08-28 02:53:08 +03:00
|
|
|
package buffer
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
2019-01-19 23:37:59 +03:00
|
|
|
"errors"
|
2018-08-28 02:53:08 +03:00
|
|
|
"io"
|
|
|
|
"os"
|
|
|
|
"os/exec"
|
|
|
|
"os/signal"
|
|
|
|
"path/filepath"
|
2019-01-25 02:25:59 +03:00
|
|
|
"unicode"
|
|
|
|
"unicode/utf8"
|
2018-08-28 02:53:08 +03:00
|
|
|
|
2019-02-04 07:17:24 +03:00
|
|
|
"github.com/zyedidia/micro/internal/config"
|
2019-12-23 01:24:00 +03:00
|
|
|
"github.com/zyedidia/micro/internal/screen"
|
2019-12-27 01:59:23 +03:00
|
|
|
"github.com/zyedidia/micro/internal/util"
|
2019-01-24 03:06:20 +03:00
|
|
|
"golang.org/x/text/encoding"
|
|
|
|
"golang.org/x/text/encoding/htmlindex"
|
|
|
|
"golang.org/x/text/transform"
|
2018-08-28 02:53:08 +03:00
|
|
|
)
|
|
|
|
|
2019-01-14 05:06:58 +03:00
|
|
|
// LargeFileThreshold is the number of bytes when fastdirty is forced
|
|
|
|
// because hashing is too slow
|
|
|
|
const LargeFileThreshold = 50000
|
|
|
|
|
|
|
|
// overwriteFile opens the given file for writing, truncating if one exists, and then calls
|
|
|
|
// the supplied function with the file as io.Writer object, also making sure the file is
|
|
|
|
// closed afterwards.
|
2019-01-24 03:06:20 +03:00
|
|
|
func overwriteFile(name string, enc encoding.Encoding, fn func(io.Writer) error) (err error) {
|
2019-01-14 05:06:58 +03:00
|
|
|
var file *os.File
|
|
|
|
|
|
|
|
if file, err = os.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
defer func() {
|
|
|
|
if e := file.Close(); e != nil && err == nil {
|
|
|
|
err = e
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
2019-01-24 03:06:20 +03:00
|
|
|
w := transform.NewWriter(file, enc.NewEncoder())
|
|
|
|
// w := bufio.NewWriter(file)
|
2019-01-14 05:06:58 +03:00
|
|
|
|
|
|
|
if err = fn(w); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-01-24 03:06:20 +03:00
|
|
|
// err = w.Flush()
|
2019-01-14 05:06:58 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-12-23 01:24:00 +03:00
|
|
|
// overwriteFileAsRoot executes dd as root and then calls the supplied function
|
|
|
|
// with dd's standard input as an io.Writer object. Dd opens the given file for writing,
|
|
|
|
// truncating it if it exists, and writes what it receives on its standard input to the file.
|
|
|
|
func overwriteFileAsRoot(name string, enc encoding.Encoding, fn func(io.Writer) error) (err error) {
|
|
|
|
cmd := exec.Command(config.GlobalSettings["sucmd"].(string), "dd", "status=none", "bs=4K", "of="+name)
|
|
|
|
var stdin io.WriteCloser
|
|
|
|
|
|
|
|
screenb := screen.TempFini()
|
|
|
|
|
|
|
|
// This is a trap for Ctrl-C so that it doesn't kill micro
|
|
|
|
// Instead we trap Ctrl-C to kill the program we're running
|
|
|
|
c := make(chan os.Signal, 1)
|
|
|
|
signal.Notify(c, os.Interrupt)
|
|
|
|
go func() {
|
|
|
|
for range c {
|
|
|
|
cmd.Process.Kill()
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
if stdin, err = cmd.StdinPipe(); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if err = cmd.Start(); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
e := fn(stdin)
|
|
|
|
|
|
|
|
if err = stdin.Close(); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if err = cmd.Wait(); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
screen.TempStart(screenb)
|
|
|
|
|
|
|
|
return e
|
|
|
|
}
|
|
|
|
|
2018-08-28 02:53:08 +03:00
|
|
|
// Save saves the buffer to its default path
|
|
|
|
func (b *Buffer) Save() error {
|
|
|
|
return b.SaveAs(b.Path)
|
|
|
|
}
|
|
|
|
|
|
|
|
// SaveAs saves the buffer to a specified path (filename), creating the file if it does not exist
|
2019-08-04 07:01:57 +03:00
|
|
|
func (b *Buffer) SaveAs(filename string) error {
|
2019-12-23 01:24:00 +03:00
|
|
|
return b.saveToFile(filename, false)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *Buffer) SaveWithSudo() error {
|
|
|
|
return b.SaveAsWithSudo(b.Path)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *Buffer) SaveAsWithSudo(filename string) error {
|
|
|
|
return b.saveToFile(filename, true)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *Buffer) saveToFile(filename string, withSudo bool) error {
|
2019-08-04 07:01:57 +03:00
|
|
|
var err error
|
2019-08-05 00:22:24 +03:00
|
|
|
if b.Type.Readonly {
|
|
|
|
return errors.New("Cannot save readonly buffer")
|
|
|
|
}
|
2019-01-19 23:37:59 +03:00
|
|
|
if b.Type.Scratch {
|
|
|
|
return errors.New("Cannot save scratch buffer")
|
|
|
|
}
|
|
|
|
|
2018-08-28 02:53:08 +03:00
|
|
|
b.UpdateRules()
|
2019-01-25 02:25:59 +03:00
|
|
|
if b.Settings["rmtrailingws"].(bool) {
|
|
|
|
for i, l := range b.lines {
|
|
|
|
leftover := utf8.RuneCount(bytes.TrimRightFunc(l.data, unicode.IsSpace))
|
|
|
|
|
|
|
|
linelen := utf8.RuneCount(l.data)
|
|
|
|
b.Remove(Loc{leftover, i}, Loc{linelen, i})
|
|
|
|
}
|
|
|
|
|
|
|
|
b.RelocateCursors()
|
|
|
|
}
|
2018-08-28 02:53:08 +03:00
|
|
|
|
|
|
|
if b.Settings["eofnewline"].(bool) {
|
|
|
|
end := b.End()
|
|
|
|
if b.RuneAt(Loc{end.X - 1, end.Y}) != '\n' {
|
2019-01-17 06:32:33 +03:00
|
|
|
b.Insert(end, "\n")
|
2018-08-28 02:53:08 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update the last time this file was updated after saving
|
|
|
|
defer func() {
|
2019-12-27 01:59:23 +03:00
|
|
|
b.ModTime, _ = util.GetModTime(filename)
|
2019-06-15 22:50:37 +03:00
|
|
|
err = b.Serialize()
|
2018-08-28 02:53:08 +03:00
|
|
|
}()
|
|
|
|
|
|
|
|
// Removes any tilde and replaces with the absolute path to home
|
2019-12-27 01:59:23 +03:00
|
|
|
absFilename, _ := util.ReplaceHome(filename)
|
2018-08-28 02:53:08 +03:00
|
|
|
|
2019-08-04 07:01:57 +03:00
|
|
|
// Get the leading path to the file | "." is returned if there's no leading path provided
|
|
|
|
if dirname := filepath.Dir(absFilename); dirname != "." {
|
|
|
|
// Check if the parent dirs don't exist
|
|
|
|
if _, statErr := os.Stat(dirname); os.IsNotExist(statErr) {
|
|
|
|
// Prompt to make sure they want to create the dirs that are missing
|
|
|
|
if b.Settings["mkparents"].(bool) {
|
|
|
|
// Create all leading dir(s) since they don't exist
|
|
|
|
if mkdirallErr := os.MkdirAll(dirname, os.ModePerm); mkdirallErr != nil {
|
|
|
|
// If there was an error creating the dirs
|
|
|
|
return mkdirallErr
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return errors.New("Parent dirs don't exist, enable 'mkparents' for auto creation")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-08-28 02:53:08 +03:00
|
|
|
|
|
|
|
var fileSize int
|
|
|
|
|
2019-01-24 03:06:20 +03:00
|
|
|
enc, err := htmlindex.Get(b.Settings["encoding"].(string))
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-12-23 01:24:00 +03:00
|
|
|
fwriter := func(file io.Writer) (e error) {
|
2018-08-28 02:53:08 +03:00
|
|
|
if len(b.lines) == 0 {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// end of line
|
|
|
|
var eol []byte
|
2019-01-15 07:24:49 +03:00
|
|
|
if b.Endings == FFDos {
|
2018-08-28 02:53:08 +03:00
|
|
|
eol = []byte{'\r', '\n'}
|
|
|
|
} else {
|
|
|
|
eol = []byte{'\n'}
|
|
|
|
}
|
|
|
|
|
|
|
|
// write lines
|
|
|
|
if fileSize, e = file.Write(b.lines[0].data); e != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, l := range b.lines[1:] {
|
|
|
|
if _, e = file.Write(eol); e != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if _, e = file.Write(l.data); e != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
fileSize += len(eol) + len(l.data)
|
|
|
|
}
|
|
|
|
return
|
2019-12-23 01:24:00 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if withSudo {
|
|
|
|
err = overwriteFileAsRoot(absFilename, enc, fwriter)
|
|
|
|
} else {
|
|
|
|
err = overwriteFile(absFilename, enc, fwriter)
|
|
|
|
}
|
2018-08-28 02:53:08 +03:00
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if !b.Settings["fastdirty"].(bool) {
|
|
|
|
if fileSize > LargeFileThreshold {
|
|
|
|
// For large files 'fastdirty' needs to be on
|
|
|
|
b.Settings["fastdirty"] = true
|
|
|
|
} else {
|
|
|
|
calcHash(b, &b.origHash)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
b.Path = filename
|
|
|
|
absPath, _ := filepath.Abs(filename)
|
|
|
|
b.AbsPath = absPath
|
2019-01-15 00:52:25 +03:00
|
|
|
b.isModified = false
|
2019-08-04 07:01:57 +03:00
|
|
|
return err
|
2018-08-28 02:53:08 +03:00
|
|
|
}
|