internal/buffer/save.go

   1 package buffer
   2
   3 import (
   4         "bufio"
   5         "bytes"
   6         "errors"
   7         "io"
   8         "os"
   9         "os/exec"
  10         "os/signal"
  11         "path/filepath"
  12         "runtime"
  13         "unicode"
  14         "unicode/utf8"
  15
  16         "github.com/zyedidia/micro/internal/config"
  17         "github.com/zyedidia/micro/internal/screen"
  18         "github.com/zyedidia/micro/internal/util"
  19         "golang.org/x/text/encoding"
  20         "golang.org/x/text/encoding/htmlindex"
  21         "golang.org/x/text/transform"
  22 )
  23
  24 // LargeFileThreshold is the number of bytes when fastdirty is forced
  25 // because hashing is too slow
  26 const LargeFileThreshold = 50000
  27
  28 // overwriteFile opens the given file for writing, truncating if one exists, and then calls
  29 // the supplied function with the file as io.Writer object, also making sure the file is
  30 // closed afterwards.
  31 func overwriteFile(name string, enc encoding.Encoding, fn func(io.Writer) error, withSudo bool) (err error) {
  32         var writeCloser io.WriteCloser
  33
  34         if withSudo {
  35                 cmd := exec.Command(config.GlobalSettings["sucmd"].(string), "dd", "bs=4k", "of="+name)
  36
  37                 if writeCloser, err = cmd.StdinPipe(); err != nil {
  38                         return
  39                 }
  40
  41                 c := make(chan os.Signal, 1)
  42                 signal.Notify(c, os.Interrupt)
  43                 go func() {
  44                         <-c
  45                         cmd.Process.Kill()
  46                 }()
  47
  48                 defer func() {
  49                         screenb := screen.TempFini()
  50                         if e := cmd.Run(); e != nil && err == nil {
  51                                 err = e
  52                         }
  53                         screen.TempStart(screenb)
  54                 }()
  55         } else if writeCloser, err = os.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644); err != nil {
  56                 return
  57         }
  58
  59         w := bufio.NewWriter(transform.NewWriter(writeCloser, enc.NewEncoder()))
  60         err = fn(w)
  61         w.Flush()
  62
  63         if e := writeCloser.Close(); e != nil && err == nil {
  64                 err = e
  65         }
  66
  67         return
  68 }
  69
  70 // Save saves the buffer to its default path
  71 func (b *Buffer) Save() error {
  72         return b.SaveAs(b.Path)
  73 }
  74
  75 // SaveAs saves the buffer to a specified path (filename), creating the file if it does not exist
  76 func (b *Buffer) SaveAs(filename string) error {
  77         return b.saveToFile(filename, false)
  78 }
  79
  80 func (b *Buffer) SaveWithSudo() error {
  81         return b.SaveAsWithSudo(b.Path)
  82 }
  83
  84 func (b *Buffer) SaveAsWithSudo(filename string) error {
  85         return b.saveToFile(filename, true)
  86 }
  87
  88 func (b *Buffer) saveToFile(filename string, withSudo bool) error {
  89         var err error
  90         if b.Type.Readonly {
  91                 return errors.New("Cannot save readonly buffer")
  92         }
  93         if b.Type.Scratch {
  94                 return errors.New("Cannot save scratch buffer")
  95         }
  96         if withSudo && runtime.GOOS == "windows" {
  97                 return errors.New("Save with sudo not supported on Windows")
  98         }
  99
 100         b.UpdateRules()
 101         if b.Settings["rmtrailingws"].(bool) {
 102                 for i, l := range b.lines {
 103                         leftover := utf8.RuneCount(bytes.TrimRightFunc(l.data, unicode.IsSpace))
 104
 105                         linelen := utf8.RuneCount(l.data)
 106                         b.Remove(Loc{leftover, i}, Loc{linelen, i})
 107                 }
 108
 109                 b.RelocateCursors()
 110         }
 111
 112         if b.Settings["eofnewline"].(bool) {
 113                 end := b.End()
 114                 if b.RuneAt(Loc{end.X - 1, end.Y}) != '\n' {
 115                         b.Insert(end, "\n")
 116                 }
 117         }
 118
 119         // Update the last time this file was updated after saving
 120         defer func() {
 121                 b.ModTime, _ = util.GetModTime(filename)
 122                 err = b.Serialize()
 123         }()
 124
 125         // Removes any tilde and replaces with the absolute path to home
 126         absFilename, _ := util.ReplaceHome(filename)
 127
 128         // Get the leading path to the file | "." is returned if there's no leading path provided
 129         if dirname := filepath.Dir(absFilename); dirname != "." {
 130                 // Check if the parent dirs don't exist
 131                 if _, statErr := os.Stat(dirname); os.IsNotExist(statErr) {
 132                         // Prompt to make sure they want to create the dirs that are missing
 133                         if b.Settings["mkparents"].(bool) {
 134                                 // Create all leading dir(s) since they don't exist
 135                                 if mkdirallErr := os.MkdirAll(dirname, os.ModePerm); mkdirallErr != nil {
 136                                         // If there was an error creating the dirs
 137                                         return mkdirallErr
 138                                 }
 139                         } else {
 140                                 return errors.New("Parent dirs don't exist, enable 'mkparents' for auto creation")
 141                         }
 142                 }
 143         }
 144
 145         var fileSize int
 146
 147         enc, err := htmlindex.Get(b.Settings["encoding"].(string))
 148         if err != nil {
 149                 return err
 150         }
 151
 152         fwriter := func(file io.Writer) (e error) {
 153                 if len(b.lines) == 0 {
 154                         return
 155                 }
 156
 157                 // end of line
 158                 var eol []byte
 159                 if b.Endings == FFDos {
 160                         eol = []byte{'\r', '\n'}
 161                 } else {
 162                         eol = []byte{'\n'}
 163                 }
 164
 165                 // write lines
 166                 if fileSize, e = file.Write(b.lines[0].data); e != nil {
 167                         return
 168                 }
 169
 170                 for _, l := range b.lines[1:] {
 171                         if _, e = file.Write(eol); e != nil {
 172                                 return
 173                         }
 174                         if _, e = file.Write(l.data); e != nil {
 175                                 return
 176                         }
 177                         fileSize += len(eol) + len(l.data)
 178                 }
 179                 return
 180         }
 181
 182         if err = overwriteFile(absFilename, enc, fwriter, withSudo); err != nil {
 183                 return err
 184         }
 185
 186         if !b.Settings["fastdirty"].(bool) {
 187                 if fileSize > LargeFileThreshold {
 188                         // For large files 'fastdirty' needs to be on
 189                         b.Settings["fastdirty"] = true
 190                 } else {
 191                         calcHash(b, &b.origHash)
 192                 }
 193         }
 194
 195         b.Path = filename
 196         absPath, _ := filepath.Abs(filename)
 197         b.AbsPath = absPath
 198         b.isModified = false
 199         return err
 200 }