ver 2009.10.14 → 2009.11.28

data/lib/ver/methods/ctags.rb

@@ -0,0 +1,55 @@
+module VER
+  module Methods
+    module Ctags
+      def ctags_find_current
+        word = get('insert wordstart', 'insert wordend')
+        ctags_find(word)
+      end
+
+      def ctags_find(needle)
+        ctags_content do |tag_name, file_name, ex_cmd|
+          next unless tag_name == needle
+          return ctags_execute(file_name, ex_cmd)
+        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
+        when /^\/(.*)\/$/
+          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
+          end
+        else
+          raise ArgumentError, "Unknown Ex command: %p" % [ex_cmd]
+        end
+      end
+
+      def ctags_content
+        dir = filename.dirname
+        file = nil
+
+        loop do
+          file = dir/'tags'
+          break if file.file? || dir.root?
+          dir = dir.parent
+        end
+
+        return unless file.file?
+
+        file.open 'rb' do |io|
+          io.each_line do |line|
+            head, tail = line.split(/;"\t/, 2)
+            yield(*head.split("\t"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ver/methods/delete.rb

@@ -0,0 +1,30 @@
+module VER
+  module Methods
+    module Delete
+      def change_motion(motion, count = 1)
+        delete_motion(motion, count)
+        start_insert_mode
+      end
+
+      def delete_motion(motion, count = 1)
+        delete(*virtual_movement(motion, count))
+      end
+
+      def delete_line(count = 1)
+        count.times do
+          delete 'insert linestart', 'insert lineend + 1 char'
+        end
+      end
+
+      def change_line(count = 1)
+        delete_line(count)
+        start_insert_mode
+      end
+
+      def delete_trailing_whitespace
+        tag_all_trailing_whitespace
+        execute :delete, *tag_ranges('invalid.trailing-whitespace').flatten
+      end
+    end
+  end
+end

data/lib/ver/methods/help.rb

@@ -0,0 +1,7 @@
+module VER
+  module Methods
+    module Help
+      include VER::Help::Methods
+    end
+  end
+end

data/lib/ver/methods/insert.rb

@@ -1,6 +1,238 @@
 module VER
   module Methods
     module Insert
+      def insert_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
+        if VER.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
+
+        clean_line('insert - 1 line')
+        start_insert_mode
+      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')
+        end
+
+        clean_line('insert + 1 line')
+        start_insert_mode
+      end
+
+      def insert_newline
+        insert :insert, "\n"
+      end
+
+      def insert_indented_newline
+        if VER.options.autoindent
+          fallback_insert_indented_newline
+        else
+          insert_newline
+        end
+      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)
+        else
+          indent_size = line[/^\s*/].size
+          return 0 if indent_size == 0
+          return indent_size / 2
+        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
+
+        index = index(index)
+        indent ||= (index.y > 1 ? indent_after(index.prev) : 0)
+
+        linestart, lineend  = index.linestart, index.lineend
+        line = get(linestart, lineend).strip
+
+        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
+        end
+
+        return indent
+      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)
+        end
+
+        return indent
+      end
+
+      def fallback_insert_indented_newline
+        line1 = get('insert linestart', 'insert lineend')
+        indentation1 = line1[/^\s+/] || ''
+        insert :insert, "\n"
+
+        line2 = get('insert linestart', 'insert lineend')
+        indentation2 = line2[/^\s+/] || ''
+
+        replace(
+          'insert linestart',
+          "insert linestart + #{indentation2.size} chars",
+          indentation1
+        )
+
+        clean_line('insert - 1 line')
+      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)
+        return if string.empty?
+
+        if !string.frozen? && string.encoding == Encoding::ASCII_8BIT
+          begin
+            string.encode!(@encoding)
+          rescue Encoding::UndefinedConversionError
+            string.force_encoding(@encoding)
+          end
+        end
+
+        # puts "Insert %p in mode %p" % [string, keymap.mode]
+        insert :insert, string
+      end
+
+      def auto_indent_line
+        if @syntax
+          syntax_indent_line
+        end
+      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
+
+
+        [:increase, :decrease, :indent_next, :unindented].each do |key|
+          if value = indent_settings[key]
+            indent_settings[key] = Regexp.new(value)
+          else
+            indent_settings.delete(key)
+          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
+
+        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)
+          end
+        end
+      end
     end
   end
-end
+end

data/lib/ver/methods/move.rb

@@ -1,64 +1,213 @@
 module VER
   module Methods
     module Move
-      def go_char_left(count = 1)
-        mark_set :insert, "insert - #{count} char"
+      GO_MATCHING_RIGHT = {
+        '(' => ')',
+        '{' => '}',
+        '[' => ']',
+        '<' => '>',
+      }
+      GO_MATCHING_LEFT = GO_MATCHING_RIGHT.invert
+
+      def matching_brace(count = nil)
+        opening = get(:insert)
+
+        if closing = GO_MATCHING_RIGHT[opening]
+          search = method(:search_all)
+          level = 1
+          start = 'insert + 1 chars'
+        elsif closing = GO_MATCHING_LEFT[opening]
+          search = method(:rsearch_all)
+          level = 1
+          start = 'insert'
+        else
+          return
+        end
+
+        needle = Regexp.union(opening, closing)
+
+        search.call(needle, start) do |match, pos, from|
+          if match == opening
+            level += 1
+          elsif match == closing
+            level -= 1
+          end
+
+          if level < 1
+            mark_set :insert, pos
+            return
+          end
+        end
       end
 
-      def go_char_right(count = 1)
-        mark_set :insert, "insert + #{count} char"
+      # Move cursor +count+ characters left.
+      def backward_char(count = 1)
+        mark_set :insert, "insert - #{count} char"
       end
 
-      def go_line_up(count = 1)
-        mark_set :insert, "insert - #{count} line"
+      # Move cursor +count+ characters right.
+      def forward_char(count = 1)
+        mark_set :insert, "insert + #{count} char"
       end
 
-      def go_line_down(count = 1)
-        mark_set :insert, "insert + #{count} line"
+      def beginning_of_line(count = nil)
+        mark_set :insert, 'insert display linestart'
       end
 
-      def go_word_left
-        mark_set :insert, 'insert - 1 char'
-        mark_set :insert, 'insert wordstart'
+      def end_of_line(count = nil)
+        mark_set :insert, 'insert display lineend'
       end
 
-      def go_word_right
-        mark_set :insert, 'insert + 1 char'
-        mark_set :insert, 'insert wordend'
+      def eol_then_insert_mode(count = nil)
+        end_of_line
+        start_insert_mode
       end
 
-      def go_beginning_of_line
-        mark_set :insert, 'insert linestart'
+      def sol_then_insert_mode
+        beginning_of_line
+        start_insert_mode
       end
 
-      def go_end_of_line
-        mark_set :insert, 'insert lineend'
+      def forward_char_then_insert_mode
+        forward_char
+        start_insert_mode
       end
 
       def go_line(number = 0)
         mark_set :insert, "#{number}.0"
       end
 
-      def go_end_of_file
-        mark_set :insert, :end
+      def end_of_file(count = nil)
+        if count
+          mark_set :insert, "#{count}.0"
+        else
+          mark_set :insert, :end
+        end
+      end
+
+      def virtual_movement(name, count = 1)
+        pos = index(:insert)
+        __send__(name, count)
+        mark = index(:insert)
+        mark_set :insert, pos
+        return [pos, mark].sort
+      rescue => ex
+        VER.error(ex)
+      end
+
+      # HACK: but it's just too good to do it manually
+
+      def page_up(count = 1)
+        mark_set :insert, tk_prev_page_pos(count)
+      end
+
+      def page_down(count = 1)
+        mark_set :insert, tk_next_page_pos(count)
+      end
+
+      def previous_line(count = 1)
+        mark_set :insert, tk_prev_line_pos(count)
+      end
+
+      def next_line(count = 1)
+        mark_set :insert, tk_next_line_pos(count)
+      end
+
+      def forward_word(count = 1)
+        count.times do
+          original_type = type = char_type(get(:insert))
+          changed = 0
+
+          begin
+            original_pos = index(:insert)
+            execute :mark, :set, :insert, 'insert + 1 chars'
+            break if  original_pos == index(:insert)
+
+            type = char_type(get(:insert))
+            changed += 1 if type != original_type
+            original_type = type
+          end until changed > 0 && type != :space
+        end
+
+        Tk::Event.generate(self, '<<Movement>>')
+      rescue => ex
+        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)
+        count.times do
+          original_type = type = char_type(get(:insert))
+          changed = 0
+
+          begin
+            original_pos = index(:insert)
+            execute :mark, :set, :insert, 'insert - 1 chars'
+            break if index(:insert) == original_pos
+
+            type = char_type(get(:insert))
+            changed += 1 if type != original_type
+            original_type = type
+          end until changed > 0 && type != :space
+
+          type = char_type(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'))
+          end
+        end
+
+        Tk::Event.generate(self, '<<Movement>>')
+      rescue => ex
+        VER.error(ex)
       end
 
-      def go_page_up
-        height = Tk.root.winfo_height
-        linespace = cget(:font).metrics(:linespace)
-        diff = height / linespace
+      private
 
-        mark_set :insert, "insert - #{diff} line"
-        see :insert
+      def char_type(char)
+        case char
+        when /\w/; :word
+        when /\S/; :special
+        when /\s/; :space
+        else; raise "You cannot get here"
+        end
       end
 
-      def go_page_down
-        height = Tk.root.winfo_height
-        linespace = cget(:font).metrics(:linespace)
-        diff = height / linespace
+      def tk_prev_word_pos(start)
+        Tk.execute('tk::TextPrevPos', tk_pathname, start, 'tcl_startOfPreviousWord').to_s
+      end
+
+      def tk_next_word_pos(start)
+        Tk.execute('tk::TextNextPos', tk_pathname, start, 'tcl_startOfNextWord').to_s
+      end
+
+      def tk_next_word_pos_end(start)
+        Tk.execute('tk::TextNextWord', tk_pathname, start).to_s
+      end
+
+      def tk_prev_line_pos(count)
+        Tk.execute('tk::TextUpDownLine', tk_pathname, -count.abs).to_s
+      end
+
+      def tk_next_line_pos(count)
+        Tk.execute('tk::TextUpDownLine', tk_pathname, count).to_s
+      end
+
+      def tk_prev_page_pos(count)
+        Tk.execute('tk::TextScrollPages', tk_pathname, -count.abs).to_s
+      end
 
-        mark_set :insert, "insert + #{diff} line"
-        see :insert
+      def tk_next_page_pos(count)
+        Tk.execute('tk::TextScrollPages', tk_pathname, count).to_s
       end
     end
   end