ver 2009.12.14 → 2010.02

data/lib/ver/methods/ctags.rb

@@ -1,62 +1,71 @@
 module VER
   module Methods
-    module Ctags
-      def ctags_find_current
-        word = get('insert wordstart', 'insert wordend')
-        ctags_find(word)
+    # TODO: add project directory and Dir.pwd to lookup path, maybe share code
+    #       with the project directory lookup
+    module CTags
+      module_function
+
+      def find_current(text)
+        word = text.get('insert wordstart', 'insert wordend')
+        find(text, word)
+      end
+
+      def prev(text, count = text.prefix_count)
+        bm = VER.ctag_stack.pop(count).first
+
+        if bm
+          Bookmark.open(text, bm)
+        else
+          message("Tag stack empty.")
+        end
       end
 
-      def ctags_go(name = nil)
+      def go(text, name = nil)
         if name
-          ctags_content do |tag_name, file_name, ex_cmd|
+          content text do |tag_name, file_name, ex_cmd|
             next unless tag_name == name
-            return ctags_execute(file_name, ex_cmd)
+            return execute(text, file_name, ex_cmd)
           end
         else
-          status_ask 'Tag name: ' do |tag_name|
-            ctags_go(tag_name)
+          text.ask 'Tag name: ' do |answer, action|
+            case action
+            when :attempt
+              go(text, answer)
+              :abort
+            end
           end
         end
       end
 
-      def ctags_find(needle)
-        ctags_content do |tag_name, file_name, ex_cmd|
+      def find(text, needle)
+        content text do |tag_name, file_name, ex_cmd|
           next unless tag_name == needle
-          return ctags_execute(file_name, ex_cmd)
-        end
-      end
-
-      def ctags_prev
-        if bm = VER.ctag_stack.pop
-          bookmark_open(bm)
-        else
-          message("Tag stack empty.")
+          return execute(text, file_name, ex_cmd)
         end
       end
 
-      def ctags_execute(file_name, ex_cmd)
+      def execute(text, file_name, ex_cmd)
         case ex_cmd
         when /^\d+$/
-          VER.ctag_stack << Bookmarks::Bookmark.new(nil, *bookmark_value)
+          VER.ctag_stack << Bookmarks::Bookmark.new(nil, *Bookmark.value(text))
 
-          view.find_or_create(file_name, ex_cmd.to_i)
+          VER.find_or_create_buffer(file_name, ex_cmd.to_i)
         when /^\/(.*)\/$/
-          VER.ctag_stack << Bookmarks::Bookmark.new(nil, *bookmark_value)
+          VER.ctag_stack << Bookmarks::Bookmark.new(nil, *Bookmark.value(text))
 
           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
+          VER.find_or_create_buffer(file_name) do |buffer|
+            Search.jump(buffer.text, regexp)
           end
         else
           raise ArgumentError, "Unknown Ex command: %p" % [ex_cmd]
         end
       end
 
-      def ctags_content
-        dir = filename.dirname
+      def content(text)
+        dir = text.filename.dirname
         file = nil
 
         loop do

data/lib/ver/methods/delete.rb

@@ -1,9 +1,11 @@
 module VER
   module Methods
     module Delete
-      def change_motion(motion, count = 1)
-        delete_motion(motion, count)
-        start_insert_mode
+      module_function
+
+      def change_motion(text, motion, count = text.prefix_count)
+        delete_motion(text, motion, count)
+        text.minor_mode(:control, :insert)
       end
 
       # Given a +motion+, this method will execute a virtual movement with the
@@ -13,9 +15,10 @@ module VER
       # @param [#to_i] count
       #
       # @see delete
-      # @see VER::Move#virtual_movement
-      def delete_motion(motion, count = 1)
-        delete(*virtual_movement(motion, count))
+      # @see VER::Move::virtual_movement
+      def delete_motion(text, motion, count = text.prefix_count)
+        movement = Move.virtual(text, motion, count)
+        delete(text, *movement)
       end
 
       # Given a +motion+, this method will execute a virtual movement with the
@@ -26,8 +29,18 @@ module VER
       #
       # @see kill
       # @see VER::Move#virtual_movement
-      def kill_motion(motion, count = 1)
-        kill(*virtual_movement(motion, count))
+      def kill_motion(text, motion, count = text.prefix_count)
+        movement = Move.virtual(text, motion, count)
+        kill(text, *movement)
+      end
+
+      # [word_right_end] goes to the last character, that is, the insert mark is
+      # between the second to last and last character.
+      # This means that the range to delete is off by one, account for it here.
+      def change_word_right_end(text, count = text.prefix_count)
+        index = Move.index_at_word_right_end(text, count)
+        delete(text, :insert, index + 1)
+        text.minor_mode(:control, :insert)
       end
 
       # Delete current line and upto +count+ subsequent lines.
@@ -36,11 +49,11 @@ module VER
       #
       # @see delete
       # @see kill_line
-      def delete_line(count = 1)
-        from = index('insert linestart')
+      def delete_line(text, count = text.prefix_count)
         count = count.abs - 1
-        to = index("#{from.y + count}.#{from.x} lineend + 1 char")
-        delete(from, to)
+        from = text.index('insert linestart')
+        to = "#{from.y + count}.#{from.x} lineend + 1 char"
+        delete(text, from, text.index(to))
       end
 
       # Copy current line and upto +count+ subsequent lines and delete them.
@@ -49,37 +62,39 @@ module VER
       #
       # @see kill
       # @see delete_line
-      def kill_line(count = 1)
-        from = index('insert linestart')
+      def kill_line(text, count = text.prefix_count)
         count = count.abs - 1
-        to = index("#{from.y + count.to_i}.#{from.x} lineend + 1 char")
-        kill(from, to)
+        from = text.index('insert linestart')
+        to = "#{from.y + count.to_i}.#{from.x} lineend + 1 char"
+        kill(text, from, text.index(to))
       end
 
       # Wrapper for [kill_line] that starts insert mode after killing +count+
-      # lines.
+      # lines. It also doesn't delete the newline.
       #
       # @param [#to_i] count Number of lines to kill
       #
       # @see kill_line
-      # @see start_insert_mode
-      def change_line(count = 1)
-        kill_line(count)
-        start_insert_mode
+      def change_line(text, count = text.prefix_count)
+        count = count.abs - 1
+        from = text.index('insert linestart')
+        to = "#{from.y + count}.#{from.x} lineend"
+        kill(text, from, text.index(to))
+        text.minor_mode(:control, :insert)
       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
+      def delete_trailing_whitespace(text)
+        ranges = text.tag_ranges('invalid.trailing-whitespace').flatten
+        text.execute(:delete, *ranges) unless ranges.empty?
       end
 
       # Delete text between +indices+
-      def delete(*indices)
+      def delete(text, *indices)
         indices_size = indices.size
         return if indices_size == 0
 
-        undo_record do |record|
+        Undo.record text do |record|
           if indices_size == 1
             record.delete(indices.first)
           else
@@ -96,15 +111,16 @@ module VER
       # @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)
+      def kill(text, *indices)
         if indices.size > 2
-          deleted = indices.each_slice(2).map{|left, right| get(left, right) }
+          deleted = indices.each_slice(2).map{|left, right|
+            text.get(left, right) }
         else
-          deleted = get(*indices)
+          deleted = text.get(*indices)
         end
 
-        copy(deleted)
-        delete(*indices)
+        Clipboard.copy(text, deleted)
+        delete(text, *indices)
       end
     end
   end

data/lib/ver/methods/help.rb

@@ -1,7 +1,15 @@
 module VER
   module Methods
     module Help
-      include VER::Help::Methods
+      module_function
+
+      def help_for_help
+        VER::Help::HelpForHelp.new(self)
+      end
+
+      def describe_key
+        VER::Help::DescribeKey.new(self)
+      end
     end
   end
 end

data/lib/ver/methods/insert.rb

@@ -1,150 +1,73 @@
 module VER
   module Methods
     module Insert
-      def insert_file_contents(filename)
+      module_function
+
+      def file_contents(filename)
         content = read_file(filename)
         insert :insert, content
       rescue Errno::ENOENT => ex
         VER.error(ex)
       end
 
-      def insert_selection
-        insert :insert, Tk::Selection.get
-      end
-
-      def insert_tab
-        insert :insert, "\t"
-      end
-
-      def insert_indented_newline_below
-        undo_record do |record|
-          if options.autoindent
-            line = get('insert linestart', 'insert lineend')
-
-            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', record)
-          start_insert_mode
-        end
-      end
-
-      def insert_indented_newline_above
-        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
-      end
-
-      def insert_newline
-        insert :insert, "\n"
+      def selection(text)
+        text.insert(:insert, Tk::Selection.get)
       end
 
-      def insert_indented_newline
-        if options.autoindent
-          fallback_insert_indented_newline
-        else
-          insert_newline
-        end
+      def tab(text)
+        text.insert(:insert, "\t")
       end
 
-      def insert_auto_indented_newline
-        insert 'insert lineend', "\n"
-        indent_fix_at('insert', indent_fix('insert - 1 line', indent_after('insert - 2 line')))
-      rescue Errno::ENOENT, TypeError
-        fallback_insert_indented_newline
-      end
-
-      def indent_of(index)
-        index = index(index)
-        return 0 if index.y < 1
-
-        line = get(index.linestart, index.lineend)
-
-        if line =~ /^\s*$/
-          return indent_of(index.prev)
+      def newline(text)
+        if text.options.autoindent
+          indented_newline(text)
         else
-          indent_size = line[/^\s*/].size
-          return 0 if indent_size == 0
-          return indent_size / 2
+          text.insert(:insert, "\n")
         end
       end
 
-      def indent_after(index, indent = nil)
-        settings = indent_settings.values_at(:increase, :decrease, :indent_next, :unindented)
-
-        return unless settings.any?
-        increase, decrease, indent_next, unindented = settings
+      def newline_below(text)
+        Undo.record text do |record|
+          if text.options.autoindent
+            # text.mark_set('insert', 'insert lineend')
+            # Indent.insert_newline(text, record)
+            line = text.get('insert linestart', 'insert lineend')
 
-        index = index(index)
-        indent ||= (index.y > 1 ? indent_after(index.prev) : 0)
-
-        linestart, lineend  = index.linestart, index.lineend
-        line = get(linestart, lineend).strip
+            indent = line[/^\s*/]
+            text.mark_set(:insert, 'insert lineend')
+            record.insert(:insert, "\n#{indent}")
+          else
+            text.mark_set(:insert, 'insert lineend')
+            record.insert(:insert, "\n")
+          end
 
-        if increase && decrease && line =~ increase && line =~ decrease
-          indent -= 1
-          indent += 1
-        elsif decrease && line =~ decrease
-          indent -= 1
-        elsif increase && line =~ increase
-          indent += 1
-        elsif line =~ /^\s*$/
-        else
+          Control.clean_line(text, 'insert - 1 line', record)
         end
 
-        return indent
+        text.minor_mode(:control, :insert)
       end
 
-      def indent_fix_at(index, indent)
-        settings = indent_settings.values_at(:increase, :decrease, :indent_next, :unindented)
-
-        return unless settings.any?
-        increase, decrease, indent_next, unindented = settings
-
-        index = index(index)
-
-        linestart, lineend  = index.linestart, index.lineend
-        line = get(linestart, lineend).strip
-
-        if increase && decrease && line =~ increase && line =~ decrease
-          indent -= 1
-          replace(linestart, lineend, ('  ' * indent) << line)
-          indent += 1
-        elsif decrease && line =~ decrease
-          replace(linestart, lineend, ('  ' * indent) << line)
-          indent -= 1
-        elsif increase && line =~ increase
-          replace(linestart, lineend, ('  ' * indent) << line)
-          indent += 1
-        elsif line =~ /^\s*$/
-          replace(linestart, lineend, ('  ' * indent) << line)
-        else
-          replace(linestart, lineend, ('  ' * indent) << line)
+      def newline_above(text)
+        Undo.record text do |record|
+          if text.index(:insert).y > 1
+            Move.prev_line(text)
+            newline_below(text)
+          else
+            record.insert('insert linestart', "\n")
+            text.mark_set(:insert, 'insert - 1 line')
+            Control.clean_line(text, 'insert - 1 line', record)
+            text.minor_mode(:control, :insert)
+          end
         end
-
-        return indent
       end
 
-      def fallback_insert_indented_newline
-        undo_record do |record|
-          line1 = get('insert linestart', 'insert lineend')
+      def indented_newline(text)
+        Undo.record text do |record|
+          line1 = text.get('insert linestart', 'insert lineend')
           indentation1 = line1[/^\s+/] || ''
-          record.insert :insert, "\n"
+          record.insert(:insert, "\n")
 
-          line2 = get('insert linestart', 'insert lineend')
+          line2 = text.get('insert linestart', 'insert lineend')
           indentation2 = line2[/^\s+/] || ''
 
           record.replace(
@@ -153,106 +76,47 @@ module VER
             indentation1
           )
 
-          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, record = self)
-        return if string.empty?
-
-        if !string.frozen? && string.encoding == Encoding::ASCII_8BIT
-          begin
-            string.encode!(@encoding)
-          rescue Encoding::UndefinedConversionError
-            string.force_encoding(@encoding)
-          end
+          Control.clean_line(text, 'insert - 1 line', record)
         end
-
-        # puts "Insert %p in mode %p" % [string, keymap.mode]
-        record.insert(:insert, string)
       end
 
-      def start_replace_mode
-        self.mode = :replace
+      # Most of the input will be in US-ASCII, but an encoding can be set per
+      # buffer 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 string(text)
+        common_string(text, text.event.unicode)
       end
 
-      def replace_string(string)
-        return if string.empty?
-
-        undo_record do |record|
+      def replace_string(text, replacement = text.event.unicode)
+        Undo.record text do |record|
           record.delete(:insert, 'insert + 1 chars')
-          insert_string(string, record)
+          common_string(text, replacement, record)
         end
       end
 
-      def auto_indent_line
-        if @syntax
-          syntax_indent_line
+      def replace_char(text, replacement = text.event.unicode)
+        Undo.record text do |record|
+          record.delete(:insert, 'insert + 1 chars')
+          common_string(text, replacement, record)
         end
+        text.mark_set(:insert, 'insert - 1 chars')
+        text.minor_mode(:replace_char, :control)
       end
 
-      def indent_settings
-        return {} unless @syntax
-        name = @syntax.name
-        file = VER.find_in_loadpath("preferences/#{name}.json")
-        pref = JSON.load(File.read(file))
-
-        indent_settings = {}
-
-        pref.each do |key, value|
-          settings = value['settings']
-          indent_settings[:increase]    ||= settings['increaseIndentPattern']
-          indent_settings[:decrease]    ||= settings['decreaseIndentPattern']
-          indent_settings[:indent_next] ||= settings['indentNextLinePattern']
-          indent_settings[:unindented]  ||= settings['unIndentedLinePattern']
-        end
-
+      def common_string(text, string, record = text)
+        return if string.empty?
 
-        [:increase, :decrease, :indent_next, :unindented].each do |key|
-          if value = indent_settings[key]
-            indent_settings[key] = Regexp.new(value)
-          else
-            indent_settings.delete(key)
+        if !string.frozen? && string.encoding == Encoding::ASCII_8BIT
+          begin
+            string.encode!(text.encoding)
+          rescue Encoding::UndefinedConversionError
+            string.force_encoding(string.encoding)
           end
         end
 
-        return indent_settings
-      end
-
-      def syntax_indent_file
-        settings = indent_settings.values_at(:increase, :decrease, :indent_next, :unindented)
-
-        return unless settings.any?
-        increase, decrease, indent_next, unindented = settings
-
-        empty_line = /^\s*$/
-        indent = 0
-        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
+        # puts "Insert %p in mode %p" % [string, keymap.mode]
+        record.insert(:insert, string)
       end
     end
   end