redcar-dev 0.12.17dev

data/plugins/document_search/features/step_definitions/find_steps.rb

@@ -0,0 +1,16 @@
+
+When /^I open the incremental search speedbar$/ do
+  Redcar::DocumentSearch::OpenIncrementalSearchSpeedbarCommand.new.run
+end
+
+When /^I open the find speedbar$/ do
+  Redcar::DocumentSearch::OpenFindSpeedbarCommand.new.run
+end
+
+Then /^I should see the incremental search speedbar$/ do
+  Then "the Redcar::DocumentSearch::IncrementalSearchSpeedbar speedbar should be open"
+end
+
+Then /^I should see the find speedbar$/ do
+  Then "the Redcar::DocumentSearch::FindSpeedbar speedbar should be open"
+end

data/plugins/document_search/features/support/env.rb

@@ -0,0 +1,14 @@
+
+def reset_search_settings(options)
+  if options
+    options.is_regex    = Redcar::DocumentSearch::QueryOptions::DEFAULT_IS_REGEX
+    options.match_case  = Redcar::DocumentSearch::QueryOptions::DEFAULT_MATCH_CASE
+    options.wrap_around = Redcar::DocumentSearch::QueryOptions::DEFAULT_WRAP_AROUND
+  end
+end
+
+Before do
+  reset_search_settings(Redcar::DocumentSearch::IncrementalSearchSpeedbar.previous_options)
+  reset_search_settings(Redcar::DocumentSearch::FindSpeedbar.previous_options)
+end
+

data/plugins/document_search/lib/document_search.rb

@@ -0,0 +1,191 @@
+require 'strscan'
+require "document_search/query_options"
+require "document_search/commands"
+require "document_search/find_speedbar"
+require "document_search/incremental_search_speedbar"
+
+module Redcar
+  module DocumentSearch
+    def self.menus
+      Redcar::Menu::Builder.build do
+        sub_menu "Edit" do
+          sub_menu "Find", :priority => 50 do
+            item "Incremental Search",        OpenIncrementalSearchSpeedbarCommand
+            item "Find...",                   OpenFindSpeedbarCommand
+            separator
+            item "Find Next",                 DoFindNextCommand
+            item "Find Previous",             DoFindPreviousCommand
+            separator
+            item "Replace All",               DoReplaceAllCommand
+            item "Replace All in Selection",  DoReplaceAllInSelectionCommand
+            item "Replace and Find",          DoReplaceAndFindCommand
+            separator
+            item "Use Selection for Find",    DoUseSelectionForFindCommand
+            item "Use Selection for Replace", DoUseSelectionForReplaceCommand
+          end
+          separator
+        end
+      end
+    end
+
+    def self.keymaps
+      osx = Redcar::Keymap.build("main", :osx) do
+        link "Ctrl+S",      DocumentSearch::OpenIncrementalSearchSpeedbarCommand
+        link "Cmd+F",       DocumentSearch::OpenFindSpeedbarCommand
+        link "Cmd+G",       DocumentSearch::DoFindNextCommand
+        link "Cmd+Shift+G", DocumentSearch::DoFindPreviousCommand
+        link "Cmd+Ctrl+F",  DocumentSearch::DoReplaceAllCommand
+        link "Cmd+Ctrl+Shift+F",  DocumentSearch::DoReplaceAllInSelectionCommand
+        link "Cmd+Alt+F",   DocumentSearch::DoReplaceAndFindCommand
+        link "Cmd+E",       DocumentSearch::DoUseSelectionForFindCommand
+        link "Cmd+Shift+E", DocumentSearch::DoUseSelectionForReplaceCommand
+      end
+
+      linwin = Redcar::Keymap.build("main", [:linux, :windows]) do
+        link "Alt+S",        DocumentSearch::OpenIncrementalSearchSpeedbarCommand
+        link "Ctrl+F",       DocumentSearch::OpenFindSpeedbarCommand
+        link "Ctrl+G",       DocumentSearch::DoFindNextCommand
+        link "Ctrl+Shift+G", DocumentSearch::DoFindPreviousCommand
+        link "Ctrl+Alt+F",   DocumentSearch::DoReplaceAndFindCommand
+        link "Ctrl+E",       DocumentSearch::DoUseSelectionForFindCommand
+        link "Alt+Shift+E",  DocumentSearch::DoUseSelectionForReplaceCommand
+      end
+
+      [linwin, osx]
+    end
+
+    def self.toolbars
+      Redcar::ToolBar::Builder.build do
+        item "Find", :command => DocumentSearch::OpenIncrementalSearchSpeedbarCommand, :icon => File.join(Redcar.icons_directory, "magnifier.png"), :barname => :edit
+        item "Find Next", :command => DocumentSearch::DoFindNextCommand, :icon => File.join(Redcar.icons_directory, "magnifier--arrow.png"), :barname => :edit
+      end
+    end
+
+    class OpenIncrementalSearchSpeedbarCommand < Redcar::EditTabCommand
+      def execute
+        already_open = win.speedbar.is_a? IncrementalSearchSpeedbar
+        @speedbar = IncrementalSearchSpeedbar.new
+        unless already_open
+          # Clear out previous query for new speedbar.
+          IncrementalSearchSpeedbar.previous_query = ''
+          win.open_speedbar(@speedbar)
+        else
+          # If already open, find next match.
+          win.open_speedbar(@speedbar)
+          IncrementalSearchSpeedbar.find_next
+        end
+      end
+    end
+
+    class OpenFindSpeedbarCommand < Redcar::EditTabCommand
+      def execute
+        @speedbar = FindSpeedbar.new
+        if doc.selection?
+          @speedbar.initial_query = doc.selected_text
+        end
+        win.open_speedbar(@speedbar)
+      end
+    end
+
+    class DoFindNextCommand < Redcar::EditTabCommand
+      def execute
+        if win.speedbar.is_a? IncrementalSearchSpeedbar
+          IncrementalSearchSpeedbar.find_next
+        else
+          FindSpeedbar.find_next
+        end
+      end
+    end
+
+    class DoFindPreviousCommand < Redcar::EditTabCommand
+      def execute
+        if win.speedbar.is_a? IncrementalSearchSpeedbar
+          IncrementalSearchSpeedbar.find_previous
+        else
+          FindSpeedbar.find_previous
+        end
+      end
+    end
+
+    class DoReplaceAndFindCommand < Redcar::EditTabCommand
+      def execute
+        FindSpeedbar.replace_and_find(
+            FindSpeedbar.previous_query,
+            FindSpeedbar.previous_replace,
+            FindSpeedbar.previous_options)
+      end
+    end
+
+    class DoReplaceAllCommand < Redcar::EditTabCommand
+      def execute
+        FindSpeedbar.replace_all(
+            FindSpeedbar.previous_query,
+            FindSpeedbar.previous_replace,
+            FindSpeedbar.previous_options)
+      end
+    end
+
+    class DoReplaceAllInSelectionCommand < Redcar::EditTabCommand
+      def execute
+        FindSpeedbar.replace_all_in_selection(
+            FindSpeedbar.previous_query,
+            FindSpeedbar.previous_replace,
+            FindSpeedbar.previous_options)
+      end
+    end
+
+    class DoUseSelectionForFindCommand  < Redcar::EditTabCommand
+      def execute
+        FindSpeedbar.use_selection_for_find(doc, win.speedbar)
+      end
+    end
+
+    class DoUseSelectionForReplaceCommand  < Redcar::EditTabCommand
+      def execute
+        FindSpeedbar.use_selection_for_replace(doc, win.speedbar)
+      end
+    end
+
+    # TODO(yozhipozhi): Figure out if this is still needed.
+    class FindNextRegex < Redcar::DocumentCommand
+      def initialize(re, wrap=nil)
+        @re = re
+        @wrap = wrap
+      end
+
+      def to_s
+        "<#{self.class}: @re:#{@re.inspect} wrap:#{!!@wrap}>"
+      end
+
+      def execute
+        position = doc.cursor_offset
+        sc       = StringScanner.new(doc.get_all_text)
+        sc.pos   = position
+        sc.scan_until(@re)
+
+        if @wrap and !sc.matched?
+          # No match was found in the remainder of the document, search from beginning
+          sc.reset
+          sc.scan_until(@re)
+        end
+
+        if sc.matched?
+          endoff   = sc.pos
+          startoff = sc.pos - sc.matched_size
+          line     = doc.line_at_offset(startoff)
+          lineoff  = startoff - doc.offset_at_line(line)
+          if lineoff < doc.smallest_visible_horizontal_index
+            horiz = lineoff
+          else
+            horiz = endoff - doc.offset_at_line(line)
+          end
+          doc.set_selection_range(sc.pos, sc.pos - sc.matched_size)
+          doc.scroll_to_line(line)
+          doc.scroll_to_horizontal_offset(horiz) if horiz
+          return true
+        end
+        false
+      end
+    end
+  end
+end

data/plugins/document_search/lib/document_search/commands.rb

@@ -0,0 +1,307 @@
+module Redcar
+  module DocumentSearch
+    # Utilities for extended search commands.
+    module FindCommandMixin
+      ### QUERY PATTERNS ###
+
+      # Indicates if the query is valid.
+      def is_valid(query)
+        query.inspect != "//i"
+      end
+
+      # An instance of a search type method: Regular expression
+      def make_regex_query(query, options)
+        Regexp.new(query, !options.match_case)
+      end
+
+      # An instance of a search type method: Plain text search
+      def make_literal_query(query, options)
+        make_regex_query(Regexp.escape(query), options)
+      end
+
+      ### SELECTION ###
+
+      # Returns the document selection range as byte offsets, adjusting for multi-byte characters.
+      def selection_byte_offsets
+        char_offsets = [doc.cursor_offset, doc.selection_offset]
+        min_char_offset = char_offsets.min
+        max_char_offset = char_offsets.max
+
+        # For the min_byte_offset, get all document text before the selection, and count the bytes.
+        min_byte_offset = doc.get_range(0, min_char_offset).size
+        # If the selection is non-empty, count the bytes in the selection text, too.
+        max_byte_offset = (min_byte_offset +
+            (max_char_offset > min_char_offset ?
+             doc.get_slice(min_char_offset, max_char_offset).size :
+             0))
+        [min_byte_offset, max_byte_offset]
+      end
+
+      # Selects the first match of query, starting from the start_pos.
+      def select_next_match(doc, start_pos, query, wrap_around)
+        return false unless is_valid(query)
+        scanner = StringScanner.new(doc.get_all_text)
+        scanner.pos = start_pos
+        if not scanner.scan_until(query)
+          if not wrap_around
+            return false
+          end
+
+          scanner.reset
+          if not scanner.scan_until(query)
+            return false
+          end
+        end
+
+        selection_pos = scanner.pos - scanner.matched_size
+        select_range_bytes(selection_pos, scanner.pos)
+        true
+      end
+
+      # Selects the match that first precedes the search position.
+      #
+      # The current implementation is brain-dead, but works: the document is scanned from the start
+      # up to the search position, retaining the most recent match. Many smarter, but more
+      # complicated strategies are possible; the best would be full reversal of the query regex, but
+      # that obviously has a lot of tricky aspects to it.
+      def select_previous_match(doc, search_pos, query, wrap_around)
+        return false unless is_valid(query)
+        previous_match = nil
+        scanner = StringScanner.new(doc.get_all_text)
+        scanner.pos = 0
+        while scanner.scan_until(query)
+          start_pos = scanner.pos - scanner.matched_size
+          if start_pos < search_pos
+            previous_match = [start_pos, scanner.pos]
+          elsif previous_match
+            select_range_bytes(*previous_match)
+            return true
+          elsif not wrap_around
+            return false
+          else
+            break
+          end
+        end
+
+        # Find the last match in the document.
+        while scanner.scan_until(query)
+          start_pos = scanner.pos - scanner.matched_size
+          previous_match = [start_pos, scanner.pos]
+        end
+
+        if previous_match
+          select_range_bytes(*previous_match)
+          return true
+        else
+          return false
+        end
+      end
+
+      # Replaces the current selection, if it matches the query completely.
+      def replace_selection_if_match(doc, start_pos, query, replace)
+        scanner = StringScanner.new(doc.selected_text)
+        scanner.check(query)
+        if (not scanner.matched?) || (scanner.matched_size != doc.selected_text.length)
+          return 0
+        end
+        matched_text = doc.get_range(start_pos, scanner.matched_size)
+        replacement_text = matched_text.gsub(query, replace)
+        doc.replace(start_pos, scanner.matched_size, replacement_text)
+        replacement_text.length
+      end
+
+      # Selects the specified range and scrolls to the start.
+      def select_range(start, stop)
+        line     = doc.line_at_offset(start)
+        lineoff  = start - doc.offset_at_line(line)
+        if lineoff < doc.smallest_visible_horizontal_index
+          horiz = lineoff
+        else
+          horiz = stop - doc.offset_at_line(line)
+        end
+        doc.set_selection_range(start, stop)
+        doc.scroll_to_line(line)
+        doc.scroll_to_horizontal_offset(horiz) if horiz
+      end
+
+      # Selects the specified byte range, mapping to character indices first.
+      #
+      # This method is necessary, because Ruby (1.8) strings really work in terms of bytes, and thus
+      # our regex and scanning matches return byte ranges, while the editor view deals in terms of
+      # character ranges.
+      def select_range_bytes(start, stop)
+        text = doc.get_all_text
+        # Unpack span up to start into array of Unicode chars and count for start_chars.
+        start_chars = text.slice(0, start).unpack('U*').size
+        # Do the same for the span between start and stop, and then use to compute stop_chars.
+        char_span   = text.slice(start, stop - start).unpack('U*').size
+        stop_chars  = start_chars + char_span
+        select_range(start_chars, stop_chars)
+      end
+    end
+
+
+    # Base class for find commands.
+    class FindCommandBase < Redcar::DocumentCommand
+      include FindCommandMixin
+
+      attr_reader :query, :options, :always_start_within_selection
+
+      # description here
+      def initialize(q, opt)
+        @options = opt
+        @query = opt.is_regex ? make_regex_query(q, opt) : make_literal_query(q, opt)
+      end
+    end
+
+
+    # Finds the next match after the current location.
+    class FindNextCommand < FindCommandBase
+      def initialize(q, opt, always_start_within_selection=false)
+        super(q, opt)
+        @always_start_within_selection = always_start_within_selection
+      end
+
+      def execute
+        # We first determine where to start the search, either from the begin or end of the current
+        # selection.
+        #
+        # If always_start_within_selection is true, then we always start at the beginning; this is
+        # needed for incremental search.
+        #
+        # Otherwise, we check if the current selection matches the query:
+        # * If it does match, we start after the selection, assuming that the selection matches
+        #   because of a prior search, and we want to move on to the next occurrence.
+        # * If it doesn't match, we start at the beginning of the selection, to handle cases where
+        #   the selection is actually the start of a match, e.g. the "Foo" portion of "Foobar" is
+        #   selected, and the user sets the query to "Foobar"; then we want Find Next to simply
+        #   expand the selection to span "Foobar" as the next match.
+        #
+        # TODO(yozhipozhi): Test this behavior!
+        start_within_selection = true
+        if !@always_start_within_selection && (doc.selected_text.length > 0)
+          text = doc.selected_text
+          m = query.match(text)
+          if (m && (m[0].length == text.length))
+            start_within_selection = false
+          end
+        end
+        offsets = selection_byte_offsets
+        start_pos = start_within_selection ? offsets[0] : offsets[1]
+
+        # Do selection.
+        if select_next_match(doc, start_pos, query, options.wrap_around)
+          true
+        else
+          # Clear selection as visual feedback that search failed.
+          select_range_bytes(start_pos, start_pos)
+          false
+        end
+      end
+    end
+
+
+    # Finds the previous match before the current location.
+    class FindPreviousCommand < FindCommandBase
+      def execute
+        offsets = selection_byte_offsets
+        start_pos = offsets.min
+        if select_previous_match(doc, start_pos, query, @options.wrap_around)
+          true
+        else
+          # Clear selection as visual feedback that search failed.
+          select_range_bytes(start_pos, start_pos)
+          false
+        end
+      end
+    end
+
+
+    # Base class for replace commands.
+    class ReplaceCommandBase < Redcar::DocumentCommand
+      include FindCommandMixin
+
+      attr_reader :query, :replace
+
+      # description here
+      def initialize(query, replace, options)
+        @options = options
+        @query =
+        options.is_regex ? make_regex_query(query, options) : make_literal_query(query, options)
+        @replace = replace
+      end
+    end
+
+
+    # Replaces the currently selected text, if it matches the search criteria, then finds and
+    # selects the next match in the document.
+    #
+    # This command maintains the invariant that no text is replaced without first being selected,
+    # so the user always knows exactly what change is about to be made. A ramification of this
+    # policy is that, if no text is selected beforehand, or the selected text does not match the
+    # query, then "replace" portion of "replace and find" is essentially skipped, so that two button
+    # presses are required.
+    class ReplaceAndFindCommand < ReplaceCommandBase
+      def execute
+        offsets = selection_byte_offsets
+        start_pos = offsets.min
+        if doc.selected_text.length > 0
+          chars_replaced = replace_selection_if_match(doc, start_pos, query, replace)
+          if chars_replaced > 0
+            start_pos += chars_replaced
+          else
+            start_pos = offsets.max
+          end
+        end
+        if select_next_match(doc, start_pos, query, @options.wrap_around)
+          true
+        else
+          # Clear selection as visual feedback that search failed.
+          select_range_bytes(start_pos, start_pos)
+          false
+        end
+      end
+    end
+
+
+    # Replaces all query matches.
+    class ReplaceAllCommand < ReplaceCommandBase
+      def initialize(query, replace, options, selection_only)
+        super(query, replace, options)
+        @selection_only = selection_only
+      end
+
+      def execute
+        startoff, endoff = nil
+        text = @selection_only ? doc.selected_text : doc.get_all_text
+        count = 0
+        sc = StringScanner.new(text)
+        while sc.scan_until(query)
+          count += 1
+
+          startoff = sc.pos - sc.matched_size
+          replacement_text = text.slice(startoff, sc.matched_size).gsub(query, replace)
+          endoff = startoff + replacement_text.length
+
+          text[startoff...sc.pos] = replacement_text
+          sc.string = text
+          sc.pos = startoff + replacement_text.length
+        end
+        if count > 0
+          if @selection_only
+            offsets = selection_byte_offsets
+            startoff = offsets.min
+            doc.replace(startoff, doc.selected_text.length, text)
+            select_range_bytes(startoff, startoff + text.length)
+          else
+            doc.text = text
+            select_range_bytes(startoff, startoff + replacement_text.length)
+          end
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end