ver 2010.02 → 2010.08

data/lib/ver/methods/search.rb

@@ -7,152 +7,240 @@ module VER
       }
       TAG = :search
 
+      CHAR_OPPOSITES = {
+        char_left: :char_right,
+        char_right: :char_left,
+        till_char_left: :till_char_right,
+        till_char_right: :till_char_left,
+      }
+
       module_function
 
-      def jump(text, needle)
-        tag(text, needle)
-        self.next(text)
+      def jump(buffer, needle)
+        tag(buffer, needle)
+        self.next(buffer)
       end
 
-      def remove(text)
-        text.tag_remove(TAG, 1.0, :end)
+      def remove(buffer)
+        buffer.tag_remove(TAG, 1.0, :end)
       end
       alias clear remove
       module_function :clear
 
-      def status_next(text)
-        status_common(text, '/'){ self.next(text) }
+      def status_next(buffer)
+        status_common(buffer, '/'){ self.next(buffer) }
       end
 
-      def status_prev(text)
-        status_common(text, '?'){ prev(text) }
+      def status_prev(buffer)
+        status_common(buffer, '?'){ prev(buffer) }
       end
 
-      def status_common(text, question)
-        text.ask question do |answer, action|
+      def status_common(buffer, question)
+        buffer.ask question do |answer, action|
           case action
           when :modified
-            incremental(text, answer)
+            incremental(buffer, answer)
           when :attempt
-            incremental(text, answer, force = true)
-            prev(text)
+            incremental(buffer, answer, force = true)
+            prev(buffer)
             yield
             :abort
           end
         end
       end
 
-      def incremental(text, term, force = false)
-        return if !term || term.empty?
-        return if !force && term.size <= text.options.search_incremental_min
-
-        begin
-          needle = Regexp.new(term)
-        rescue RegexpError, SyntaxError
-          needle = Regexp.escape(term)
-        end
+      def incremental(buffer, term, force = false)
+        needle =
+          case term
+          when nil, false
+            return
+          when Regexp
+            needle = term
+          when String
+            return if !force && term.size <= buffer.options.search_incremental_min
+            return if term.empty?
+            begin
+              Regexp.new(term)
+            rescue RegexpError, SyntaxError
+              Regexp.escape(term)
+            end
+          else
+            raise ArgumentError
+          end
 
-        tag(text, needle)
-        from, to = text.tag_nextrange(TAG, 1.0, :end)
-        text.see(from) if from
+        tag(buffer, needle)
+        from, to = buffer.tag_nextrange(TAG, 1.0, :end)
+        buffer.see(from) if from
       end
 
-      def first(text)
-        from, to = text.tag_nextrange(TAG, 1.0, :end)
-        text.mark_set(:insert, from) if from
+      def first(buffer)
+        from, to = buffer.tag_nextrange(TAG, 1.0, :end)
+        go(buffer, from)
       end
 
-      def last(text)
+      def last(buffer)
         from, to = tag_prevrange(TAG, :end, 1.0)
-        text.mark_set(:insert, from) if from
+        go(buffer, from)
       end
 
-      def next(text, count = text.prefix_count)
+      def next(buffer, count = buffer.prefix_count)
         count.times do
-          from, to = text.tag_nextrange(TAG, 'insert + 1 chars', 'end')
-          text.mark_set(:insert, from) if from
+          from, to = buffer.tag_nextrange(TAG, 'insert + 1 chars', 'end')
+          go(buffer, from)
         end
 
-        display_matches_count(text)
+        display_matches_count(buffer)
       end
 
-      def display_matches_count(text)
-        total = text.tag_ranges(TAG).size
+      def display_matches_count(buffer)
+        total = buffer.tag_ranges(TAG).size
 
         if total == 1
-          VER.message "1 match found"
+          buffer.message "1 match found"
         elsif total > 1
-          VER.message "#{total} matches found"
+          buffer.message "#{total} matches found"
         else
-          VER.message "No matches found"
+          buffer.message "No matches found"
         end
       end
 
-      def prev(text, count = text.prefix_count)
+      def prev(buffer, count = buffer.prefix_count)
         count.times do
-          from, to = text.tag_prevrange(TAG, 'insert - 1 chars', '1.0')
-          text.mark_set(:insert, from) if from
+          from, to = buffer.tag_prevrange(TAG, 'insert - 1 chars', '1.0')
+          go(buffer, from)
         end
 
-        display_matches_count(text)
+        display_matches_count(buffer)
       end
 
-      def next_word_under_cursor(text)
-        word = text.get('insert wordstart', 'insert wordend')
+      def next_word_under_cursor(buffer)
+        word = buffer.get('insert wordstart', 'insert wordend')
         return if word.squeeze == ' ' # we don't want to match space
-        tag(text, word)
-        self.next(text)
+        tag(buffer, word)
+        self.next(buffer)
       end
 
-      def prev_word_under_cursor(text)
-        word = text.get('insert wordstart', 'insert wordend')
+      def prev_word_under_cursor(buffer)
+        word = buffer.get('insert wordstart', 'insert wordend')
         return if word.squeeze == ' ' # we don't want to match space
-        tag(text, word)
-        prev(text)
+        tag(buffer, word)
+        prev(buffer)
       end
 
-      def char_right(text, count = text.prefix_count)
-        VER.message 'Press the character to find to the right'
+      def char_common(buffer, name, action, count)
+        buffer.major_mode.read 1 do |event|
+          regexp = Regexp.new(Regexp.escape(event.unicode))
+          buffer.store(self, :char_search, name)
+          buffer.store(self, :char_search_regexp, regexp)
+          send(action, buffer, regexp, count)
+        end
+      end
 
-        text.major_mode.read 1 do |event|
-          from, to = 'insert + 1 chars', 'insert lineend'
-          regexp = Regexp.new(Regexp.escape(event[:unicode]))
+      def char_right(buffer, count = buffer.prefix_count)
+        buffer.message 'Press the character to find to the right'
+        char_common(buffer, :char_right, :char_right!, count)
+      end
 
-          counter = 0
-          text.search_all regexp, from, to do |match, pos, mark|
-            text.mark_set :insert, pos
-            counter += 1
-            break if counter == count
-          end
+      def char_right!(buffer, regexp, count)
+        from, to = 'insert + 1 chars', 'insert lineend'
+        counter = 0
+        buffer.search_all regexp, from, to do |match, pos, mark|
+          buffer.insert = pos
+          counter += 1
+          return true if counter == count
         end
+
+        false
+      end
+
+      def till_char_right(buffer, count = buffer.prefix_count)
+        buffer.message 'Press the character to find to the right'
+        char_common(buffer, :till_char_right, :till_char_right!, count)
+      end
+
+      def till_char_right!(buffer, regexp, count)
+        return unless char_right!(buffer, regexp, count)
+        buffer.at_insert.prev_char
+      end
+
+      def char_left(buffer, count = buffer.prefix_count)
+        buffer.message 'Press the character to find to the left'
+        char_common(buffer, :char_left, :char_left!, count)
       end
 
-      def char_left(text, count = text.prefix_count)
-        VER.message 'Press the character to find to the left'
+      def char_left!(buffer, regexp, count)
+        from, to = 'insert', 'insert linestart'
+        counter = 0
 
-        text.major_mode.read 1 do |event|
-          from, to = 'insert', 'insert linestart'
-          regexp = Regexp.new(Regexp.escape(event[:unicode]))
+        buffer.rsearch_all regexp, from, to do |match, pos, mark|
+          buffer.insert = pos
+          counter += 1
+          return true if counter == count
+        end
 
-          counter = 0
-          text.rsearch_all regexp, from, to do |match, pos, mark|
-            text.mark_set(:insert, pos)
-            counter += 1
-            break if counter == count
+        false
+      end
+
+      def till_char_left(buffer, count = buffer.prefix_count)
+        buffer.message 'Press the character to find to the left'
+        char_common(buffer, :till_char_left, :till_char_left!, count)
+      end
+
+      def till_char_left!(buffer, regexp, count)
+        return unless char_left!(buffer, regexp, count)
+        buffer.at_insert.next_char
+      end
+
+      # Repeat the last {char_left}, {char_right}, {till_char_left}, or
+      # {till_char_right} search +count+ times.
+      def again_char(buffer, count = buffer.prefix_count)
+        if name = buffer.store(self, :char_search)
+          if regexp = buffer.store(self, :char_search_regexp)
+            send("#{name}!", buffer, regexp, count)
+          else
+            buffer.warn "Regexp missing, how weird!"
+          end
+        else
+          buffer.warn "No previous char search, can't repeat."
+        end
+      end
+
+      # Repeat the last {char_left}, {char_right}, {till_char_left}, or
+      # {till_char_right} search +count+ times in the opposite direction.
+      def again_char_opposite(buffer, count = buffer.prefix_count)
+        if regexp = buffer.store(self, :char_search_regexp)
+          if name = buffer.store(self, :char_search)
+            opposite = CHAR_OPPOSITES.fetch(name)
+            send("#{opposite}!", buffer, regexp, count)
+          else
+            buffer.warn "No previous char search, can't repeat."
           end
+        else
+          buffer.warn "Regexp missing, how weird!"
         end
       end
 
-      def again(text)
-        return unless needle = text.store(self, :last)
-        tag(text, needle)
-        self.next(text)
+      def again(buffer)
+        return unless needle = buffer.store(self, :last)
+        tag(buffer, needle)
+        self.next(buffer)
+      end
+
+      def tag(buffer, needle)
+        buffer.store(self, :last, needle)
+        buffer.tag_all_matching(TAG, needle, HIGHLIGHT)
+        buffer.tag_lower(TAG)
+      end
+
+      def go(buffer, index)
+        return unless index
+        center(buffer, index)
+        buffer.insert = index
       end
 
-      def tag(text, needle)
-        text.store(self, :last, needle)
-        text.tag_all_matching(TAG, needle, HIGHLIGHT)
-        text.tag_lower(TAG)
+      def center(buffer, index)
+        return unless index
+        Control.cursor_vertical_center(buffer, index)
       end
     end
   end

data/lib/ver/methods/search_and_replace.rb

@@ -6,46 +6,47 @@ module VER
 
       module_function
 
-      def leave(text, old_mode, new_mode)
-        text.tag_remove(TAG, 1.0, :end)
+      def leave(buffer, old_mode, new_mode)
+        buffer.tag_remove(TAG, 1.0, :end)
       end
 
-      def enter(text, old_mode, new_mode)
-        pattern = text.store(self, :pattern)
-        text.tag_all_matching(TAG, pattern, HIGHLIGHT)
-        from, to = text.tag_nextrange(TAG, 'insert + 1 chars', 'end')
-        text.mark_set(:insert, from) if from
+      def enter(buffer, old_mode, new_mode)
+        pattern = buffer.store(self, :pattern)
+        buffer.tag_all_matching(TAG, pattern, HIGHLIGHT)
+        from, to = buffer.tag_nextrange(TAG, 'insert + 1 chars', 'end')
+        Search.go(buffer, from)
 
-        VER.message 'Replace occurence (y)es (n)o (a)ll (q)uit'
+        buffer.message 'Replace occurence (y)es (n)o (a)ll (q)uit'
       end
 
-      def last_pattern(text)
-        pattern = text.store(self, :pattern)
+      def last_pattern(buffer)
+        pattern = buffer.store(self, :pattern)
         pattern.inspect[1..-1] if pattern
       end
 
-      def query(text)
+      def query(buffer)
         question = 'Replace pattern: /'
-        value = last_pattern(text)
+        value = last_pattern(buffer).to_s
 
-        text.ask question, value: value do |answer, action|
+        buffer.ask question, value: value do |answer, action|
           case action
           when :modified
             begin
               regexp = answer_to_regex(answer)
-              VER.warn ''
-              VER.message(" => #{regexp.inspect}")
+              Search.incremental(buffer, regexp)
+              buffer.warn ''
+              buffer.message("=> #{regexp.inspect}")
             rescue RegexpError, SyntaxError => ex
-              VER.warn(ex.message)
+              buffer.warn(ex.message)
             end
           when :attempt
             begin
               regexp = answer_to_regex(answer)
-              VER.message(" => #{regexp.inspect}")
-              VER.defer{ query_attempt(text, regexp) }
+              buffer.message("=> #{regexp.inspect}")
+              query_attempt(buffer, regexp)
               :abort
             rescue RegexpError, SyntaxError => ex
-              VER.warn(ex.message)
+              buffer.warn(ex.message)
             end
           end
         end
@@ -56,62 +57,74 @@ module VER
         eval("/#{answer}")
       end
 
-      def query_attempt(text, pattern)
+      def query_attempt(buffer, pattern)
         question = "Replace %p with: " % [pattern]
-        value = text.store(self, :replacement)
-        text.ask question, value: value do |replacement, action|
+        value = buffer.store(self, :replacement)
+        buffer.ask question, value: value do |replacement, action|
           case action
           when :attempt
-            query_done(text, pattern, replacement)
+            query_done(buffer, pattern, replacement)
             :abort
           end
         end
       end
 
-      def query_done(text, pattern, replacement)
-        text.store(self, :pattern, pattern)
-        text.store(self, :replacement, replacement)
-        text.minor_mode(:control, :search_and_replace)
+      def query_done(buffer, pattern, replacement)
+        buffer.store(self, :pattern, pattern)
+        buffer.store(self, :replacement, replacement)
+        buffer.minor_mode(:control, :search_and_replace)
       end
 
-      def replace_once(text)
-        from, to = text.tag_nextrange(TAG, 'insert', 'end')
-        text.replace(from, to, text.store(self, :replacement))
-        text.tag_all_matching(TAG, text.store(self, :pattern), HIGHLIGHT)
-        from, to = text.tag_nextrange(TAG, 'insert + 1 chars', 'end')
-        text.mark_set(:insert, from) if from
+      def replace_once(buffer)
+        begin
+          from, to = buffer.tag_nextrange(TAG, 'insert', 'end')
+          return unless from && to
+        rescue => ex
+          if ex.message.start_with?('bad text index ""')
+            buffer.minor_mode(:search_and_replace, :control)
+            buffer.message 'No more matches'
+            return
+          else
+            raise(ex)
+          end
+        end
+
+        buffer.replace(from, to, buffer.store(self, :replacement))
+        buffer.tag_all_matching(TAG, buffer.store(self, :pattern), HIGHLIGHT)
+        from, to = buffer.tag_nextrange(TAG, 'insert + 1 chars', 'end')
+        Search.go(buffer, from)
 
-        VER.message 'Replace occurence (y)es (n)o (a)ll (q)uit'
+        buffer.message 'Replace occurence (y)es (n)o (a)ll (q)uit'
       end
 
-      def replace_all(text)
-        replacement = text.store(self, :replacement)
-        from, to = text.tag_nextrange(TAG, 'insert', 'end')
+      def replace_all(buffer)
+        replacement = buffer.store(self, :replacement)
+        from, to = buffer.tag_nextrange(TAG, 'insert', 'end')
         return unless from
 
-        Undo.record text do |record|
+        Undo.record buffer do |record|
           begin
             record.replace(from, to, replacement)
-            text.mark_set(:insert, from)
-            from, to = text.tag_nextrange(TAG, 'insert + 1 chars', 'end')
+            buffer.mark_set(:insert, from)
+            from, to = buffer.tag_nextrange(TAG, 'insert + 1 chars', 'end')
           end while from
         end
 
-        text.minor_mode(:search_and_replace, :control)
+        buffer.minor_mode(:search_and_replace, :control)
       end
 
-      def next(text)
-        from, to = text.tag_nextrange(TAG, 'insert + 1 chars', 'end')
-        text.mark_set(:insert, from) if from
+      def next(buffer)
+        from, to = buffer.tag_nextrange(TAG, 'insert + 1 chars', 'end')
+        Search.go(buffer, from)
 
-        VER.message 'Replace occurence (y)es (n)o (a)ll (q)uit'
+        buffer.message 'Replace occurence (y)es (n)o (a)ll (q)uit'
       end
 
-      def prev(text)
-        from, to = text.tag_prevrange(TAG, 'insert', '1.0')
-        text.mark_set(:insert, from) if from
+      def prev(buffer)
+        from, to = buffer.tag_prevrange(TAG, 'insert', '1.0')
+        Search.go(buffer, from)
 
-        VER.message 'Replace occurence (y)es (n)o (a)ll (q)uit'
+        buffer.message 'Replace occurence (y)es (n)o (a)ll (q)uit'
       end
     end
   end