vimamsa 0.1.13 → 0.1.14

data/lib/vimamsa/buffer.rb

@@ -14,7 +14,7 @@ $ifuncon = false
 class Buffer < String
   attr_reader :pos, :lpos, :cpos, :deltas, :edit_history, :fname, :call_func, :pathname, :basename, :dirname, :update_highlight, :marks, :is_highlighted, :syntax_detect_failed, :id, :lang, :images, :last_save
   attr_writer :call_func, :update_highlight
-  attr_accessor :gui_update_highlight, :update_hl_startpos, :update_hl_endpos, :hl_queue, :syntax_parser, :highlights, :gui_reset_highlight, :is_parsing_syntax, :line_ends, :bt, :line_action_handler, :module, :active_kbd_mode, :title, :subtitle, :paste_lines
+  attr_accessor :gui_update_highlight, :update_hl_startpos, :update_hl_endpos, :hl_queue, :syntax_parser, :highlights, :gui_reset_highlight, :is_parsing_syntax, :line_ends, :bt, :line_action_handler, :module, :active_kbd_mode, :title, :subtitle, :paste_lines, :mode_stack, :default_mode
 
   @@num_buffers = 0
 
@@ -28,6 +28,8 @@ class Buffer < String
     @id = @@num_buffers
     @@num_buffers += 1
     @version = 0
+    @mode_stack = [:command] # TODO
+    @default_mode = :command # TODO
     gui_create_buffer(@id, self)
     debug "NEW BUFFER fn=#{fname} ID:#{@id}"
 
@@ -91,15 +93,14 @@ class Buffer < String
 
   def set_active
     if !@active_kbd_mode.nil?
-      $kbd.set_mode(@active_kbd_mode)
+      # $kbd.set_mode(@active_kbd_mode) #TODO: remove?
     else
       $kbd.set_mode_to_default
     end
-    # gui_set_current_buffer(@id)
   end
 
   def set_executable
-    if File.exists?(@fname)
+    if File.exist?(@fname)
       FileUtils.chmod("+x", @fname)
       message("Set executable: #{@fname}")
     end
@@ -213,6 +214,7 @@ class Buffer < String
     $audiof = mf
   end
 
+  #TODO: remove?
   def reset_audio_widget_positions
     debug "reset_audio_widget_positions", 2
     for mc in @audiofiles
@@ -246,16 +248,6 @@ class Buffer < String
     gui_set_current_buffer(@id) #TODO: needed?
   end
 
-  def is_legal_pos(pos, op = :read)
-    return false if pos < 0
-    if op == :add
-      return false if pos > self.size
-    elsif op == :read
-      return false if pos >= self.size
-    end
-    return true
-  end
-
   def set_encrypted(password)
     @crypt = Encrypt.new(password)
     message("Set buffer encrypted")
@@ -265,19 +257,18 @@ class Buffer < String
     @crypt = nil
   end
 
-  def add_new_line(txt)
-    # buf.jump(END_OF_LINE);buf.insert_txt("\n");
-  end
-
-  def insert_image_after_current_line(fname)
-    lr = current_line_range()
-    a = "⟦img:#{fname}⟧\n"
-    b = " \n"
-    txt = a + b
-    insert_txt_at(txt, lr.end + 1)
-    buf.view.handle_deltas
-    imgpos = lr.end + 1 + a.size
-    add_image(fname, imgpos)
+  def unindent
+    debug("unindent", 2)
+    conf(:tab_width).times {
+      p = @pos - 1
+      if p >= 0
+        if self[p] == " "
+          delete(BACKWARD_CHAR)
+        end
+      else
+        break
+      end
+    }
   end
 
   def handle_drag_and_drop(fname)
@@ -300,13 +291,14 @@ class Buffer < String
 
   def revert()
     return if !@fname
-    return if !File.exists?(@fname)
+    return if !File.exist?(@fname)
     message("Revert buffer #{@fname}")
     str = read_file("", @fname)
     self.set_content(str)
   end
 
   def decrypt(password)
+    return if @encrypted_str.nil?
     begin
       @crypt = Encrypt.new(password)
       str = @crypt.decrypt(@encrypted_str)
@@ -347,11 +339,9 @@ class Buffer < String
     @ftype = nil
     if str[0..10] == "VMACRYPT001"
       @encrypted_str = str[11..-1]
-      callback = proc { |x| decrypt_cur_buffer(x) }
-      gui_one_input_action("Decrypt", "Password:", "decrypt", callback, { :hide => true })
+      callback = proc { |x| self.decrypt(x) }
+      gui_one_input_action("Decrypt file \n #{@fname}", "Password:", "decrypt", callback, { :hide => true })
       str = "ENCRYPTED"
-    else
-      # @crypt = nil
     end
 
     if (str[-1] != "\n")
@@ -361,10 +351,9 @@ class Buffer < String
     self.replace(str)
     @line_ends = scan_indexes(self, /\n/)
 
-    # @bt = BufferTree.new(str)
-    if $experimental
+    if cnf.btree.experimental?
       @bt = BufferTree.new(self)
-      if $debug
+      if cnf.debug?
         sanitycheck_btree()
       end
     end
@@ -426,65 +415,6 @@ class Buffer < String
     return fpath
   end
 
-  def line(lpos)
-    if @line_ends.size == 0
-      return self
-    end
-
-    #TODO: implement using line_range()
-    if lpos >= @line_ends.size
-      debug("lpos too large") #TODO
-      return ""
-    elsif lpos == @line_ends.size
-    end
-    start = @line_ends[lpos - 1] + 1 if lpos > 0
-    start = 0 if lpos == 0
-    _end = @line_ends[lpos]
-    debug "start: _#{start}, end: #{_end}"
-    return self[start.._end]
-  end
-
-  def is_delta_ok(delta)
-    ret = true
-    pos = delta[0]
-    if pos < 0
-      ret = false
-      debug "pos=#{pos} < 0"
-    elsif pos > self.size
-      debug "pos=#{pos} > self.size=#{self.size}"
-      ret = false
-    end
-    if ret == false
-      # crash("DELTA OK=#{ret}")
-    end
-    return ret
-  end
-
-  #TODO: change to apply=true as default
-  def add_delta(delta, apply = false, auto_update_cpos = false)
-    return if !is_delta_ok(delta)
-    if delta[1] == DELETE
-      return if delta[0] >= self.size
-      # If go over length of buffer
-      if delta[0] + delta[2] >= self.size
-        delta[2] = self.size - delta[0]
-      end
-    end
-
-    @edit_version += 1
-    @redo_stack = []
-    if apply
-      delta = run_delta(delta, auto_update_cpos)
-    else
-      @deltas << delta
-    end
-    @edit_history << delta
-    if self[-1] != "\n"
-      add_delta([self.size, INSERT, 1, "\n"], true)
-    end
-    reset_larger_cpos #TODO: correct here?
-  end
-
   def add_hl_update(startpos, endpos)
     return if @is_highlighted == false
 
@@ -501,7 +431,7 @@ class Buffer < String
     # delta[3]: text to add in case of insert
 
     @version += 1
-    if $experimental
+    if cnf.btree.experimental?
       @bt.handle_delta(Delta.new(delta[0], delta[1], delta[2], delta[3]))
     end
 
@@ -585,34 +515,6 @@ class Buffer < String
     end
   end
 
-  def jump_to_last_edit()
-    return if @edit_pos_history.empty?
-    @edit_pos_history_i += 1
-
-    if @edit_pos_history_i > @edit_pos_history.size
-      @edit_pos_history_i = 0
-    end
-
-    #        if @edit_pos_history.size >= @edit_pos_history_i
-    set_pos(@edit_pos_history[-@edit_pos_history_i])
-    center_on_current_line
-    return true
-    #        end
-  end
-
-  def jump_to_next_edit()
-    return if @edit_pos_history.empty?
-    @edit_pos_history_i -= 1
-    @edit_pos_history_i = @edit_pos_history.size - 1 if @edit_pos_history_i < 0
-    debug "@edit_pos_history_i=#{@edit_pos_history_i}"
-    set_pos(@edit_pos_history[-@edit_pos_history_i])
-    center_on_current_line
-    return true
-  end
-
-  def jump_to_random_pos()
-    set_pos(rand(self.size))
-  end
 
   def undo()
     debug @edit_history.inspect
@@ -757,10 +659,10 @@ class Buffer < String
   end
 
   def get_repeat_num()
-    $method_handles_repeat = true
+    vma.kbd.method_handles_repeat = true
     repeat_num = 1
-    if !$next_command_count.nil? and $next_command_count > 0
-      repeat_num = $next_command_count
+    if !vma.kbd.next_command_count.nil? and vma.kbd.next_command_count > 0
+      repeat_num = vma.kbd.next_command_count
     end
     return repeat_num
   end
@@ -809,7 +711,7 @@ class Buffer < String
     debug range_id.inspect
     range = get_range(range_id)
     debug range.inspect
-    set_clipboard(self[range])
+    vma.clipboard.set(self[range])
   end
 
   def recalc_line_ends()
@@ -890,149 +792,7 @@ class Buffer < String
       @line_ends.sort!
     end
   end
-
-  def at_end_of_line?()
-    return (self[@pos] == "\n" or at_end_of_buffer?)
-  end
-
-  def at_end_of_buffer?()
-    return @pos == self.size
-  end
-
-  def jump_to_pos(new_pos)
-    set_pos(new_pos)
-  end
-
-  def set_pos(new_pos)
-    if new_pos >= self.size
-      @pos = self.size - 1 # TODO:??right side of last char
-    elsif new_pos >= 0
-      @pos = new_pos
-    end
-    gui_set_cursor_pos(@id, @pos)
-    calculate_line_and_column_pos
-
-    check_if_modified_outside
-  end
-
-  # Get the line number of character position
-  def get_line_pos(pos)
-    lpos = @line_ends.bsearch_index { |x, _| x >= pos }
-    return lpos
-  end
-
-  # Calculate the two dimensional column and line positions based on
-  # (one dimensional) position in the buffer.
-  def get_line_and_col_pos(pos)
-    pos = self.size if pos > self.size
-    pos = 0 if pos < 0
-
-    lpos = get_line_pos(pos)
-
-    lpos = @line_ends.size if lpos == nil
-    cpos = pos
-    cpos -= @line_ends[lpos - 1] + 1 if lpos > 0
-
-    return [lpos, cpos]
-  end
-
-  def calculate_line_and_column_pos(reset = true)
-    @lpos, @cpos = get_line_and_col_pos(@pos)
-    reset_larger_cpos if reset
-  end
-
-  def set_line_and_column_pos(lpos, cpos, _reset_larger_cpos = true)
-    @lpos = lpos if !lpos.nil?
-    @cpos = cpos if !cpos.nil?
-    if @lpos > 0
-      new_pos = @line_ends[@lpos - 1] + 1
-    else
-      new_pos = 0
-    end
-
-    if @cpos > (line(@lpos).size - 1)
-      debug("$cpos too large: #{@cpos} #{@lpos}")
-      if @larger_cpos < @cpos
-        @larger_cpos = @cpos
-      end
-      @cpos = line(@lpos).size - 1
-    end
-    new_pos += @cpos
-    set_pos(new_pos)
-    reset_larger_cpos if _reset_larger_cpos
-  end
-
-  # Calculate the one dimensional array index based on column and line positions
-  def calculate_pos_from_cpos_lpos(reset = true)
-    set_line_and_column_pos(nil, nil)
-  end
-
-  def delete2(range_id, mark = nil)
-    # if mark != nil
-    # debug mark, 2
-    # return
-    # end
-
-    @paste_lines = false
-    range = get_range(range_id, mark: mark)
-    return if range == nil
-    debug "RANGE"
-    debug range.inspect
-    debug range.inspect
-    debug "------"
-    delete_range(range.first, range.last)
-    pos = [range.first, @pos].min
-    set_pos(pos)
-  end
-
-  def delete(op, x = nil)
-    @paste_lines = false
-    # Delete selection
-    if op == SELECTION && visual_mode?
-      (startpos, endpos) = get_visual_mode_range2
-      delete_range(startpos, endpos, x)
-      @pos = [@pos, @selection_start].min
-      end_visual_mode
-      #return
-
-      # Delete current char
-    elsif op == CURRENT_CHAR_FORWARD
-      return if @pos >= self.size - 1 # May not delete last '\n'
-      add_delta([@pos, DELETE, 1], true)
-
-      # Delete current char and then move backward
-    elsif op == CURRENT_CHAR_BACKWARD
-      add_delta([@pos, DELETE, 1], true)
-      @pos -= 1
-
-      # Delete the char before current char and move backward
-    elsif op == BACKWARD_CHAR and @pos > 0
-      add_delta([@pos - 1, DELETE, 1], true)
-      @pos -= 1
-    elsif op == FORWARD_CHAR #TODO: ok?
-      add_delta([@pos + 1, DELETE, 1], true)
-    end
-    set_pos(@pos)
-    #recalc_line_ends
-    calculate_line_and_column_pos
-    #need_redraw!
-  end
-
-  def delete_range(startpos, endpos, x = nil)
-    s = self[startpos..endpos]
-    if startpos == endpos or s == ""
-      return
-    end
-    if x == :append
-      debug "APPEND"
-      s += "\n" + get_clipboard()
-    end
-    set_clipboard(s)
-    add_delta([startpos, DELETE, (endpos - startpos + 1)], true)
-    #recalc_line_ends
-    calculate_line_and_column_pos
-  end
-
+  
   # Ranges to use in delete or copy operations
   def get_range(range_id, mark: nil)
     range = nil
@@ -1040,7 +800,7 @@ class Buffer < String
       # TODO: better way to make the search than + 150 from current position
       wmarks = get_word_end_marks(@pos, @pos + 150)
       if wmarks.any?
-        range = @pos..wmarks[0]
+        range = @pos..(wmarks[0])
       end
     elsif range_id == :to_next_word # start of
       wmarks = get_word_start_marks(@pos, @pos + 150)
@@ -1324,141 +1084,6 @@ class Buffer < String
     handle_word(wnfo)
   end
 
-  def jump_to_next_instance_of_word()
-    if $kbd.last_action == $kbd.cur_action and @current_word != nil
-      # debug "REPEATING *"
-    else
-      start_search = [@pos - 150, 0].max
-
-      search_str1 = self[start_search..(@pos)]
-      wsmarks = scan_indexes(search_str1, /(?<=[^\p{Word}])\p{Word}/)
-      a = wsmarks[-1]
-      a = 0 if a == nil
-
-      search_str2 = self[(@pos)..(@pos + 150)]
-      wemarks = scan_indexes(search_str2, /(?<=\p{Word})[^\p{Word}]/)
-      b = wemarks[0]
-      word_start = (@pos - search_str1.size + a + 1)
-      word_start = 0 if !(word_start >= 0)
-      @current_word = self[word_start..(@pos + b - 1)]
-    end
-
-    #TODO: search for /[^\p{Word}]WORD[^\p{Word}]/
-    position_of_next_word = self.index(@current_word, @pos + 1)
-    if position_of_next_word != nil
-      set_pos(position_of_next_word)
-    else #Search from beginning
-      position_of_next_word = self.index(@current_word)
-      set_pos(position_of_next_word) if position_of_next_word != nil
-    end
-    center_on_current_line
-    return true
-  end
-
-  def jump_word(direction, wordpos)
-    offset = 0
-    if direction == FORWARD
-      debug "POS: #{@pos},"
-      search_str = self[(@pos)..(@pos + 250)]
-      return if search_str == nil
-      if wordpos == WORD_START # vim 'w'
-        wsmarks = scan_indexes(search_str, /(?<=[^\p{Word}])\p{Word}|\Z/) # \Z = end of string, just before last newline.
-        wsmarks2 = scan_indexes(search_str, /\n[ \t]*\n/) # "empty" lines that have whitespace
-        wsmarks2 = wsmarks2.collect { |x| x + 1 }
-        wsmarks = (wsmarks2 + wsmarks).sort.uniq
-        offset = 0
-        if wsmarks.any?
-          next_pos = @pos + wsmarks[0] + offset
-          set_pos(next_pos)
-        end
-      elsif wordpos == WORD_END
-        search_str = self[(@pos + 1)..(@pos + 150)]
-        wsmarks = scan_indexes(search_str, /(?<=\p{Word})[^\p{Word}]/)
-        offset = -1
-        if wsmarks.any?
-          next_pos = @pos + 1 + wsmarks[0] + offset
-          set_pos(next_pos)
-        end
-      end
-    end
-    if direction == BACKWARD #  vim 'b'
-      start_search = @pos - 150 #TODO 150 length limit
-      start_search = 0 if start_search < 0
-      search_str = self[start_search..(@pos - 1)]
-      return if search_str == nil
-      wsmarks = scan_indexes(search_str,
-                             #/(^|(\W)\w|\n)/) #TODO 150 length limit
-                             #/^|(?<=[^\p{Word}])\p{Word}|(?<=\n)\n/) #include empty lines?
-                             /\A|(?<=[^\p{Word}])\p{Word}/) # Start of string or nonword,word.
-
-      offset = 0
-
-      if wsmarks.any?
-        next_pos = start_search + wsmarks.last + offset
-        set_pos(next_pos)
-      end
-    end
-  end
-
-  def jump_to_mark(mark_char)
-    p = @marks[mark_char]
-    set_pos(p) if p
-    center_on_current_line
-    return true
-  end
-
-  def jump(target)
-    if target == START_OF_BUFFER
-      set_pos(0)
-    end
-    if target == END_OF_BUFFER
-      set_pos(self.size - 1)
-    end
-    if target == BEGINNING_OF_LINE
-      @cpos = 0
-      calculate_pos_from_cpos_lpos
-    end
-    if target == END_OF_LINE
-      @cpos = line(@lpos).size - 1
-      calculate_pos_from_cpos_lpos
-    end
-
-    if target == FIRST_NON_WHITESPACE
-      l = current_line()
-      debug l.inspect
-      @cpos = line(@lpos).size - 1
-      a = scan_indexes(l, /\S/)
-      debug a.inspect
-      if a.any?
-        @cpos = a[0]
-      else
-        @cpos = 0
-      end
-      calculate_pos_from_cpos_lpos
-    end
-  end
-
-  def jump_to_line(line_n = 1)
-
-    #    $method_handles_repeat = true
-    #    if !$next_command_count.nil? and $next_command_count > 0
-    #        line_n = $next_command_count
-    #        debug "jump to line:#{line_n}"
-    #    end
-    debug "jump to line:#{line_n}"
-    line_n = get_repeat_num() if line_n == 1
-
-    if line_n > @line_ends.size
-      debug("lpos too large") #TODO
-      return
-    end
-    if line_n == 1
-      set_pos(0)
-    else
-      set_pos(@line_ends[line_n - 2] + 1)
-    end
-  end
-
   def join_lines()
     if @lpos >= @line_ends.size - 1 # Cursor is on last line
       debug("ON LAST LINE")
@@ -1472,28 +1097,6 @@ class Buffer < String
     end
   end
 
-  def jump_to_next_instance_of_char(char, direction = FORWARD)
-
-    #return if at_end_of_line?
-    if direction == FORWARD
-      position_of_next_char = self.index(char, @pos + 1)
-      if position_of_next_char != nil
-        @pos = position_of_next_char
-      end
-    elsif direction == BACKWARD
-      start_search = @pos - 250
-      start_search = 0 if start_search < 0
-      search_substr = self[start_search..(@pos - 1)]
-      _pos = search_substr.reverse.index(char)
-      if _pos != nil
-        @pos -= (_pos + 1)
-      end
-    end
-    m = method("jump_to_next_instance_of_char")
-    set_last_command({ method: m, params: [char, direction] })
-    $last_find_command = { char: char, direction: direction }
-    set_pos(@pos)
-  end
 
   def replace_with_char(char)
     debug "self_pos:'#{self[@pos]}'"
@@ -1619,94 +1222,6 @@ class Buffer < String
     @need_redraw = false
   end
 
-  # Create a new line after current line and insert text on that line
-  def put_to_new_next_line(txt)
-    l = current_line_range()
-    insert_txt_at(txt, l.end + 1)
-    set_pos(l.end + 1)
-  end
-
-  # Start asynchronous read of system clipboard
-  def paste_start(at, register)
-    @clipboard_paste_running = true
-    clipboard = vma.gui.window.display.clipboard
-    clipboard.read_text_async do |_clipboard, result|
-      begin
-        text = clipboard.read_text_finish(result)
-      rescue Gio::IOError::NotSupported
-        # Happens when pasting from KeePassX and clipboard cleared
-        debug Gio::IOError::NotSupported
-      else
-        paste_finish(text, at, register)
-      end
-    end
-  end
-
-  def paste_finish(text, at, register)
-    debug "PASTE: #{text}"
-
-    # If we did not put this text to clipboard
-    if text != $clipboard[-1]
-      @paste_lines = false
-    end
-
-    text = sanitize_input(text)
-
-    $clipboard << text
-
-    return if text == ""
-
-    if @paste_lines
-      debug "PASTE LINES"
-      put_to_new_next_line(text)
-    else
-      if at_end_of_buffer? or at_end_of_line? or at == BEFORE
-        pos = @pos
-      else
-        pos = @pos + 1
-      end
-      insert_txt_at(text, pos)
-      set_pos(pos + text.size)
-    end
-    set_pos(@pos)
-    @clipboard_paste_running = false
-  end
-
-  def paste(at = AFTER, register = nil)
-    # Macro's don't work with asynchronous call using GTK
-    # TODO: implement as synchronous?
-    # Use internal clipboard
-    if vma.macro.running_macro
-      text = get_clipboard()
-      paste_finish(text, at, register)
-    else
-      # Get clipboard using GUI
-      paste_start(at, register)
-    end
-    return true
-  end
-
-  def delete_line()
-    $method_handles_repeat = true
-    num_lines = 1
-    if !$next_command_count.nil? and $next_command_count > 0
-      num_lines = $next_command_count
-      debug "copy num_lines:#{num_lines}"
-    end
-    lrange = line_range(@lpos, num_lines)
-    s = self[lrange]
-    add_delta([lrange.begin, DELETE, lrange.end - lrange.begin + 1], true)
-    set_clipboard(s)
-    update_pos(lrange.begin)
-    @paste_lines = true
-    #recalc_line_ends
-  end
-
-  def update_pos(pos)
-    @pos = pos
-    calculate_line_and_column_pos
-  end
-
   def start_visual_mode()
     @visual_mode = true
     @selection_start = @pos
@@ -1722,10 +1237,10 @@ class Buffer < String
     s = self[get_visual_mode_range]
     if x == :append
       debug "APPEND"
-      s += "\n" + get_clipboard()
+      s += "\n" + vma.clipboard.get()
     end
 
-    set_clipboard(s)
+    vma.clipboard.set(s)
     end_visual_mode
     return true
   end
@@ -1788,29 +1303,29 @@ class Buffer < String
   end
 
   def copy_line()
-    $method_handles_repeat = true
+    vma.kbd.method_handles_repeat = true
     num_lines = 1
-    if !$next_command_count.nil? and $next_command_count > 0
-      num_lines = $next_command_count
+    if !vma.kbd.next_command_count.nil? and vma.kbd.next_command_count > 0
+      num_lines = vma.kbd.next_command_count
       debug "copy num_lines:#{num_lines}"
     end
-    set_clipboard(self[line_range(@lpos, num_lines)])
+    vma.clipboard.set(self[line_range(@lpos, num_lines)])
     @paste_lines = true
   end
 
   def put_file_path_to_clipboard
-    set_clipboard(self.fname)
+    vma.clipboard.set(self.fname)
   end
 
   def put_file_ref_to_clipboard
-    set_clipboard(self.fname + ":#{@lpos}")
+    vma.clipboard.set(self.fname + ":#{@lpos}")
   end
 
   def delete_active_selection() #TODO: remove this function
     return if !@visual_mode #TODO: this should not happen
 
     _start, _end = get_visual_mode_range
-    set_clipboard(self[_start, _end])
+    vma.clipboard.set(self[_start, _end])
     end_visual_mode
   end
 
@@ -1870,7 +1385,7 @@ class Buffer < String
     savepath = ""
 
     # If current file has fname, save to that fname
-    # Else search for previously open files and save to the directory of
+    # Else search for previously opened files and save to the directory of
     # the last viewed file that has a filename
     # selffers[$buffer_history.reverse[1]].fname
 
@@ -1894,7 +1409,7 @@ class Buffer < String
     # Keeping this code from GTK3 in case want to do this manually at some point
     # if !confirmed
     # @unconfirmed_path = fpath
-    # if File.exists?(fpath) and File.file?(fpath)
+    # if File.exist?(fpath) and File.file?(fpath)
     # params = {}
     # params["title"] = "The file already exists, overwrite? \r #{fpath}"
     # params["inputs"] = {}
@@ -1903,7 +1418,7 @@ class Buffer < String
     # params[:callback] = callback
     # PopupFormGenerator.new(params).run
     # return
-    # elsif File.exists?(fpath) #and File.directory?(fpath)
+    # elsif File.exist?(fpath) #and File.directory?(fpath)
     # params = {}
     # params["title"] = "Can't write to the destination.\r #{fpath}"
     # params["inputs"] = {}
@@ -1995,44 +1510,6 @@ class Buffer < String
     write_contents_to_file(@fname)
   end
 
-  # Indents whole buffer using external program
-  def indent()
-    file = Tempfile.new("out")
-    infile = Tempfile.new("in")
-    file.write(self.to_s)
-    file.flush
-    bufc = "FOO"
-
-    tmppos = @pos
-
-    message("Auto format #{@fname}")
-
-    ftype = get_file_type()
-    if ["chdr", "c", "cpp", "cpphdr"].include?(ftype)
-
-      #C/C++/Java/JavaScript/Objective-C/Protobuf code
-      system("clang-format -style='{BasedOnStyle: LLVM, ColumnLimit: 100,  SortIncludes: false}' #{file.path} > #{infile.path}")
-      bufc = IO.read(infile.path)
-    elsif ftype == "Javascript"
-      cmd = "clang-format #{file.path} > #{infile.path}'"
-      debug cmd
-      system(cmd)
-      bufc = IO.read(infile.path)
-    elsif ftype == "ruby"
-      cmd = "rufo #{file.path}"
-      debug cmd
-      system(cmd)
-      bufc = IO.read(file.path)
-    else
-      message("No auto-format handler for file of type: #{ftype}")
-      return
-    end
-    self.update_content(bufc)
-    center_on_current_line #TODO: needed?
-    file.close; file.unlink
-    infile.close; infile.unlink
-  end
-
   def close()
     idx = vma.buffers.get_buffer_by_id(@id)
     vma.buffers.close_buffer(idx)