ver 2009.11.29 → 2009.12.14

data/lib/ver/methods/ctags.rb

@@ -6,6 +6,19 @@ module VER
         ctags_find(word)
       end
 
+      def ctags_go(name = nil)
+        if name
+          ctags_content do |tag_name, file_name, ex_cmd|
+            next unless tag_name == name
+            return ctags_execute(file_name, ex_cmd)
+          end
+        else
+          status_ask 'Tag name: ' do |tag_name|
+            ctags_go(tag_name)
+          end
+        end
+      end
+
       def ctags_find(needle)
         ctags_content do |tag_name, file_name, ex_cmd|
           next unless tag_name == needle
@@ -13,15 +26,26 @@ module VER
         end
       end
 
+      def ctags_prev
+        if bm = VER.ctag_stack.pop
+          bookmark_open(bm)
+        else
+          message("Tag stack empty.")
+        end
+      end
+
       def ctags_execute(file_name, ex_cmd)
         case ex_cmd
         when /^\d+$/
-          view.find_or_create(file_name) do |view|
-            view.text.go_line(ex_cmd.to_i)
-          end
+          VER.ctag_stack << Bookmarks::Bookmark.new(nil, *bookmark_value)
+
+          view.find_or_create(file_name, ex_cmd.to_i)
         when /^\/(.*)\/$/
-          source = $1.gsub!(/(?!\\)([()])/, '\\\\\\1')
+          VER.ctag_stack << Bookmarks::Bookmark.new(nil, *bookmark_value)
+
+          source = $1.gsub(/(?!\\)([()])/, '\\\\\\1')
           regexp = Regexp.new(source)
+
           self.view.find_or_create(file_name) do |view|
             view.text.tag_all_matching(:search, regexp, Search::SEARCH_HIGHLIGHT)
             view.text.search_next

data/lib/ver/methods/delete.rb

@@ -6,25 +6,106 @@ module VER
         start_insert_mode
       end
 
+      # Given a +motion+, this method will execute a virtual movement with the
+      # +count+ argument and [delete] the corresponding indices.
+      #
+      # @param [Symbol String] motion name of a method acceptable for [virtual_movement]
+      # @param [#to_i] count
+      #
+      # @see delete
+      # @see VER::Move#virtual_movement
       def delete_motion(motion, count = 1)
         delete(*virtual_movement(motion, count))
       end
 
+      # Given a +motion+, this method will execute a virtual movement with the
+      # +count+ argument and [kill] the corresponding indices.
+      #
+      # @param [Symbol String] motion name of a method acceptable for [virtual_movement]
+      # @param [#to_i] count
+      #
+      # @see kill
+      # @see VER::Move#virtual_movement
+      def kill_motion(motion, count = 1)
+        kill(*virtual_movement(motion, count))
+      end
+
+      # Delete current line and upto +count+ subsequent lines.
+      #
+      # @param [#to_i] count Number of lines to delete
+      #
+      # @see delete
+      # @see kill_line
       def delete_line(count = 1)
-        count.times do
-          delete 'insert linestart', 'insert lineend + 1 char'
-        end
+        from = index('insert linestart')
+        count = count.abs - 1
+        to = index("#{from.y + count}.#{from.x} lineend + 1 char")
+        delete(from, to)
       end
 
+      # Copy current line and upto +count+ subsequent lines and delete them.
+      #
+      # @param [#to_i] count Number of lines to kill
+      #
+      # @see kill
+      # @see delete_line
+      def kill_line(count = 1)
+        from = index('insert linestart')
+        count = count.abs - 1
+        to = index("#{from.y + count.to_i}.#{from.x} lineend + 1 char")
+        kill(from, to)
+      end
+
+      # Wrapper for [kill_line] that starts insert mode after killing +count+
+      # lines.
+      #
+      # @param [#to_i] count Number of lines to kill
+      #
+      # @see kill_line
+      # @see start_insert_mode
       def change_line(count = 1)
-        delete_line(count)
+        kill_line(count)
         start_insert_mode
       end
 
+      # Tag and delete all trailing whitespace in the current buffer.
       def delete_trailing_whitespace
         tag_all_trailing_whitespace
         execute :delete, *tag_ranges('invalid.trailing-whitespace').flatten
       end
+
+      # Delete text between +indices+
+      def delete(*indices)
+        indices_size = indices.size
+        return if indices_size == 0
+
+        undo_record do |record|
+          if indices_size == 1
+            record.delete(indices.first)
+          else
+            indices.each_slice(2) do |from, to|
+              next if from == to
+              record.delete(from, to)
+            end
+          end
+        end
+      end
+
+      # Copy text between +indices+ and delete it.
+      #
+      # @param [Array<Text::Index, String, Symbol>] indices
+      #   one or more indices within the buffer, must be an even number of
+      #   indices if more than one.
+      def kill(*indices)
+        if indices.size > 2
+          deleted = indices.each_slice(2).map{|left, right| get(left, right) }
+        else
+          deleted = get(*indices)
+        end
+
+        copy(deleted)
+        delete(*indices)
+      end
     end
   end
 end

data/lib/ver/methods/insert.rb

@@ -17,32 +17,35 @@ module VER
       end
 
       def insert_indented_newline_below
-        if VER.options.autoindent
-          line = get('insert linestart', 'insert lineend')
+        undo_record do |record|
+          if options.autoindent
+            line = get('insert linestart', 'insert lineend')
 
-          indent = line.empty? ? "" : (line[/^\s+/] || '')
-          mark_set :insert, 'insert lineend'
-          insert :insert, "\n#{indent}"
-        else
-          mark_set :insert, 'insert lineend'
-          insert :insert, "\n"
-        end
+            indent = line.empty? ? "" : (line[/^\s+/] || '')
+            mark_set :insert, 'insert lineend'
+            record.insert :insert, "\n#{indent}"
+          else
+            mark_set :insert, 'insert lineend'
+            record.insert :insert, "\n"
+          end
 
-        clean_line('insert - 1 line')
-        start_insert_mode
+          clean_line('insert - 1 line', record)
+          start_insert_mode
+        end
       end
 
       def insert_indented_newline_above
-        if index(:insert).y > 1
-          previous_line
-          insert_indented_newline_below
-        else
-          insert('insert linestart', "\n")
-          mark_set(:insert, 'insert - 1 line')
+        undo_record do |record|
+          if index(:insert).y > 1
+            previous_line
+            insert_indented_newline_below
+          else
+            record.insert('insert linestart', "\n")
+            mark_set(:insert, 'insert - 1 line')
+            clean_line('insert - 1 line', record)
+            start_insert_mode
+          end
         end
-
-        clean_line('insert + 1 line')
-        start_insert_mode
       end
 
       def insert_newline
@@ -50,7 +53,7 @@ module VER
       end
 
       def insert_indented_newline
-        if VER.options.autoindent
+        if options.autoindent
           fallback_insert_indented_newline
         else
           insert_newline
@@ -136,26 +139,28 @@ module VER
       end
 
       def fallback_insert_indented_newline
-        line1 = get('insert linestart', 'insert lineend')
-        indentation1 = line1[/^\s+/] || ''
-        insert :insert, "\n"
+        undo_record do |record|
+          line1 = get('insert linestart', 'insert lineend')
+          indentation1 = line1[/^\s+/] || ''
+          record.insert :insert, "\n"
 
-        line2 = get('insert linestart', 'insert lineend')
-        indentation2 = line2[/^\s+/] || ''
+          line2 = get('insert linestart', 'insert lineend')
+          indentation2 = line2[/^\s+/] || ''
 
-        replace(
-          'insert linestart',
-          "insert linestart + #{indentation2.size} chars",
-          indentation1
-        )
+          record.replace(
+            'insert linestart',
+            "insert linestart + #{indentation2.size} chars",
+            indentation1
+          )
 
-        clean_line('insert - 1 line')
+          clean_line('insert - 1 line', record)
+        end
       end
 
       # Most of the input will be in US-ASCII, but an encoding can be set per view for the input.
       # For just about all purposes, UTF-8 should be what you want to input, and it's what Tk
       # can handle best.
-      def insert_string(string)
+      def insert_string(string, record = self)
         return if string.empty?
 
         if !string.frozen? && string.encoding == Encoding::ASCII_8BIT
@@ -167,7 +172,20 @@ module VER
         end
 
         # puts "Insert %p in mode %p" % [string, keymap.mode]
-        insert :insert, string
+        record.insert(:insert, string)
+      end
+
+      def start_replace_mode
+        self.mode = :replace
+      end
+
+      def replace_string(string)
+        return if string.empty?
+
+        undo_record do |record|
+          record.delete(:insert, 'insert + 1 chars')
+          insert_string(string, record)
+        end
       end
 
       def auto_indent_line
@@ -212,24 +230,27 @@ module VER
 
         empty_line = /^\s*$/
         indent = 0
-
-        index('1.0').upto(index('end')) do |pos|
-          pos_lineend = pos.lineend
-          line = get(pos, pos_lineend).strip
-
-          if increase && decrease && line =~ increase && line =~ decrease
-            indent -= 1
-            replace(pos, pos_lineend, ('  ' * indent) << line)
-            indent += 1
-          elsif decrease && line =~ decrease
-            indent -= 1
-            replace(pos, pos_lineend, ('  ' * indent) << line)
-          elsif increase && line =~ increase
-            replace(pos, pos_lineend, ('  ' * indent) << line)
-            indent += 1
-          elsif line =~ empty_line
-          else
-            replace(pos, pos_lineend, ('  ' * indent) << line)
+        indent_token = ' ' * options.shiftwidth
+
+        undo_record do |record|
+          index('1.0').upto(index('end')) do |pos|
+            pos_lineend = pos.lineend
+            line = get(pos, pos_lineend).strip
+
+            if increase && decrease && line =~ increase && line =~ decrease
+              indent -= 1
+              record.replace(pos, pos_lineend, (indent_token * indent) << line)
+              indent += 1
+            elsif decrease && line =~ decrease
+              indent -= 1
+              record.replace(pos, pos_lineend, (indent_token * indent) << line)
+            elsif increase && line =~ increase
+              record.replace(pos, pos_lineend, (indent_token * indent) << line)
+              indent += 1
+            elsif line =~ empty_line
+            else
+              record.replace(pos, pos_lineend, (indent_token * indent) << line)
+            end
           end
         end
       end

data/lib/ver/methods/move.rb

@@ -42,34 +42,51 @@ module VER
 
       # Move cursor +count+ characters left.
       def backward_char(count = 1)
-        mark_set :insert, "insert - #{count} char"
+        mark_set :insert, "insert - #{count} displaychars"
       end
 
       # Move cursor +count+ characters right.
       def forward_char(count = 1)
-        mark_set :insert, "insert + #{count} char"
+        mark_set :insert, "insert + #{count} displaychars"
       end
 
+      # Move to the beginning of the line where insert mark is located.
+      #
+      # With +count+ it will move to the beginning of the display line, which
+      # takes line wraps into account.
       def beginning_of_line(count = nil)
-        mark_set :insert, 'insert display linestart'
+        if count
+          mark_set :insert, 'insert display linestart'
+        else
+          mark_set :insert, 'insert linestart'
+        end
       end
 
+      # Move to the end of the line where insert mark is located.
+      #
+      # With +count+ it moves to the end of the display line, so when there is
+      # a line wrap it will move to the place where the line wraps instead of the
+      # real end of the line.
       def end_of_line(count = nil)
-        mark_set :insert, 'insert display lineend'
+        if count
+          mark_set :insert, 'insert display lineend'
+        else
+          mark_set :insert, 'insert lineend'
+        end
       end
 
       def eol_then_insert_mode(count = nil)
-        end_of_line
+        end_of_line(count)
         start_insert_mode
       end
 
-      def sol_then_insert_mode
-        beginning_of_line
+      def sol_then_insert_mode(count = nil)
+        beginning_of_line(count)
         start_insert_mode
       end
 
-      def forward_char_then_insert_mode
-        forward_char
+      def forward_char_then_insert_mode(count = 1)
+        forward_char(count)
         start_insert_mode
       end
 
@@ -106,16 +123,103 @@ module VER
       end
 
       def previous_line(count = 1)
-        mark_set :insert, tk_prev_line_pos(count)
+        up_down_line(-count.abs)
+        refresh_selection
       end
 
       def next_line(count = 1)
-        mark_set :insert, tk_next_line_pos(count)
+        up_down_line(count.abs)
+        refresh_selection
+      end
+
+      # OK, finally found the issue.
+      #
+      # the implementation of tk::TextUpDownLine is smart, but not smart enough.
+      # It doesn't assume large deltas between the start of up/down movement and
+      # the last other modification of the insert mark.
+      #
+      # This means that, after scrolling with up/down for a few hundred lines,
+      # it has to calculate the amount of display lines in between, which is a
+      # very expensive calculation and time increases O(delta_lines).
+      #
+      # We'll try to solve this another way, by assuming that there are at least
+      # a few other lines of same or greater length in between, we simply
+      # compare against a closer position and make delta_lines as small as
+      # possible.
+      #
+      # Now, if you go to, like column 100 of a line, and there is never a line
+      # as long for the rest of the file, the scrolling will still slow down a
+      # lot. This is an issue we can fix if we "forget" the @udl_pos_orig after
+      # a user-defined maximum delta (something around 200 should do), will
+      # implement that on demand.
+      def up_down_line(count)
+        insert = index(:insert)
+
+        @udl_pos_orig = insert if @udl_pos_prev != insert
+
+        lines = count(@udl_pos_orig, insert, :displaylines)
+        target = index("#@udl_pos_orig + #{lines + count} displaylines")
+        @udl_pos_prev = target
+        mark_set :insert, target
+        @udl_pos_orig = target if target.x == @udl_pos_orig.x
+      end
+
+      def forward_scroll(count = 1)
+        count_abs = count.abs
+        yview_scroll(count_abs, :units)
+        next_line(count_abs)
+      end
+
+      def backward_scroll(count = 1)
+        count_abs = count.abs
+        yview_scroll(-count_abs, :units)
+        previous_line(count_abs)
       end
 
       def forward_word(count = 1)
+        forward_jump(count, &method(:word_char_type))
+      end
+
+      def forward_chunk(count = 1)
+        forward_jump(count, &method(:chunk_char_type))
+      end
+
+      def word_right_end(count = 1)
+        count.times do
+          mark_set :insert, tk_next_word_pos_end('insert')
+        end
+      end
+
+      def backward_word(count = 1)
+        backward_jump(count, &method(:word_char_type))
+      end
+
+      def backward_chunk(count = 1)
+        backward_jump(count, &method(:chunk_char_type))
+      end
+
+      private
+
+      def word_char_type(char)
+        case char
+        when /\w/; :word
+        when /\S/; :special
+        when /\s/; :space
+        else; raise "You cannot get here"
+        end
+      end
+
+      def chunk_char_type(char)
+        case char
+        when /\S/; :nonspace
+        when /\s/; :space
+        else; raise "You cannot get here"
+        end
+      end
+
+      def forward_jump(count)
         count.times do
-          original_type = type = char_type(get(:insert))
+          original_type = type = yield(get(:insert))
           changed = 0
 
           begin
@@ -123,7 +227,7 @@ module VER
             execute :mark, :set, :insert, 'insert + 1 chars'
             break if  original_pos == index(:insert)
 
-            type = char_type(get(:insert))
+            type = yield(get(:insert))
             changed += 1 if type != original_type
             original_type = type
           end until changed > 0 && type != :space
@@ -134,15 +238,9 @@ module VER
         VER.error(ex)
       end
 
-      def word_right_end(count = 1)
-        count.times do
-          mark_set :insert, tk_next_word_pos_end('insert')
-        end
-      end
-
-      def backward_word(count = 1)
+      def backward_jump(count = 1)
         count.times do
-          original_type = type = char_type(get(:insert))
+          original_type = type = yield(get(:insert))
           changed = 0
 
           begin
@@ -150,19 +248,19 @@ module VER
             execute :mark, :set, :insert, 'insert - 1 chars'
             break if index(:insert) == original_pos
 
-            type = char_type(get(:insert))
+            type = yield(get(:insert))
             changed += 1 if type != original_type
             original_type = type
           end until changed > 0 && type != :space
 
-          type = char_type(get('insert - 1 chars'))
+          type = yield(get('insert - 1 chars'))
 
           while type == original_type
             original_pos = index(:insert)
             execute :mark, :set, :insert, 'insert - 1 chars'
             break if index(:insert) == original_pos
 
-            type = char_type(get('insert - 1 chars'))
+            type = yield(get('insert - 1 chars'))
           end
         end
 
@@ -171,17 +269,6 @@ module VER
         VER.error(ex)
       end
 
-      private
-
-      def char_type(char)
-        case char
-        when /\w/; :word
-        when /\S/; :special
-        when /\s/; :space
-        else; raise "You cannot get here"
-        end
-      end
-
       def tk_prev_word_pos(start)
         Tk.execute('tk::TextPrevPos', tk_pathname, start, 'tcl_startOfPreviousWord').to_s
       end