redcar 0.10 → 0.11.0dev

data/plugins/project/lib/project/recent.rb

@@ -0,0 +1,64 @@
+module Redcar
+  class Project
+    # Purpose of this class is to have a menu that shows the 10 most recent opened files and directories
+    # This way users can quickly go to files and directories they have recently opened, or use frequently
+    class Recent
+      
+      # Create menus for recent files and directories
+      def self.storage
+        @storage ||= begin
+          storage = Plugin::Storage.new('recent')
+          storage.set_default('list', [])
+          storage.set_default('max_list_length', 100)
+          storage.set_default('max_recent_menu_length', 10)
+          storage
+        end
+      end
+      
+      def self.generate_menu(builder)
+        recent = storage['list']
+        count = 0
+        recent.each do |path|
+          if count >= storage['max_recent_menu_length']
+            break
+          end
+          count = count.next
+          
+          if File.exist?(File.expand_path(path))
+            if File.directory?(path)
+              builder.item(File.basename(path) + "/") do
+                Project::Manager.open_project_for_path(path)
+              end
+            elsif File.file?(File.expand_path(path))
+              builder.item(File.basename(path)) do
+                Project::Manager.open_file(path)
+              end
+            else
+              remove_path(path)
+            end
+          end
+        end
+      end
+            
+      
+      # Stores the given path to the text file, to appear in the recents menu.
+      #
+      # @param [String] path  the path of a file or directory to be saved
+      def self.store_path(path)
+        path = File.expand_path(path)
+        storage["list"].delete(path)
+        storage["list"].unshift(path)
+        if storage["list"].length == storage['max_list_length'] + 1
+          storage["list"].pop
+        end
+        storage.save
+      end
+      
+      def self.remove_path(path)
+        path = File.expand_path(path)
+        storage["list"].delete(path)
+        storage.save
+      end
+    end
+  end
+end

data/plugins/{find-in-project → project_search}/TODO.md

@@ -1,11 +1,11 @@
-* Speed it up! (in particular, with context). Stats below.
+* Speed up regex search (in particular, with context). Stats below.
 
 Searching for "redcar" in the Redcar source code:
   - Without Context:
     - Textmate AckMate: ~2 seconds
-    - Redcar find-in-project: ~50 seconds
+    - Redcar regex search: ~50 seconds
   - With Context:
     - Textmate AckMate: ~4 seconds
-    - Redcar find-in-project: ~5 minutes
+    - Redcar regex search: ~5 minutes
 
 * Per-project settings

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

@@ -0,0 +1,6 @@
+
+Before do
+end
+
+After do
+end

data/plugins/project_search/features/word_search.feature

@@ -0,0 +1,34 @@
+Feature: Word search
+  As a user
+  I want to search for the occurrences of complete words in my project
+
+  Background:
+    Given I will choose "plugins/project_search/spec/fixtures/project" from the "open_directory" dialog
+    And I open a directory
+    When I open the "Word Search" from the "Project" menu
+    And I wait "3" seconds
+
+  Scenario: See the search interface
+    Then I should see "Search for complete words only" in the web view
+
+  Scenario: Run a search
+    When I fill in "#query" with "foo" in the web view
+    And I press "Find In Project" in the web view
+    Then I should see "foo bar baz" in the web view
+
+  #Scenario: Opening the TODO list shows the todo items and their action texts without colons
+  #  Then the HTML tab should say "a course of action"
+  #  And the HTML tab should not say ": a course of action"
+  #
+  #Scenario: Opening the TODO list shows the todo item's file names
+  #  Then the HTML tab should say "OPTIMIZE_colon.file"
+  #  And the HTML tab should say "FIXME.file"
+  #
+  #Scenario: Opening the TODO list shows the todo item's line numbers
+  #  Then the HTML tab should say "OPTIMIZE_colon.file:1"
+  #  And the HTML tab should say "FIXME.file:3"
+  #
+  #Scenario: Clicking a TODO item's file name should open it in an edit tab
+  #  When I click "FIXME.file" in the HTML tab
+  #  Then my active tab should be "FIXME.file"
+  #  And the contents should be "#\n#\n<c># FIXME note"

data/plugins/project_search/lib/project_search.rb

@@ -0,0 +1,73 @@
+
+$:.push(File.dirname(__FILE__) + "/../vendor/lucene/lib")
+require 'lucene'
+
+require 'project_search/word_search_controller'
+require 'project_search/lucene_index'
+require 'project_search/lucene_refresh'
+require 'project_search/binary_data_detector'
+require 'project_search/commands'
+require 'project_search/hit'
+require 'project_search/word_search'
+
+class ProjectSearch
+  def self.menus
+    Redcar::Menu::Builder.build do
+      sub_menu "Project" do
+        group :priority => 1 do
+          item "Search",  :command => ProjectSearch::WordSearchCommand
+        end
+      end
+    end
+  end
+  
+  def self.keymaps
+    osx = Redcar::Keymap.build("main", :osx) do
+      link "Cmd+Shift+F",     ProjectSearch::WordSearchCommand
+    end
+    linwin = Redcar::Keymap.build("main", [:linux, :windows]) do
+      link "Ctrl+Shift+F",     ProjectSearch::WordSearchCommand
+    end
+    [osx, linwin]
+  end
+
+  def self.toolbars
+    Redcar::ToolBar::Builder.build do
+      item "Search", :command => WordSearchCommand, 
+        :icon => File.join(Redcar::ICONS_DIRECTORY, "application-search-result.png"), 
+        :barname => :project
+    end
+  end
+
+  def self.storage
+    @storage ||= begin
+      storage = Redcar::Plugin::Storage.new('find_in_project')
+      storage.set_default('recent_queries', [])
+      storage.set_default('excluded_dirs', ['.git', '.svn', '.redcar'])
+      storage.set_default('excluded_files', [])
+      storage.set_default('excluded_patterns', [/tags$/, /\.log$/])
+      storage.set_default('literal_match', false)
+      storage.set_default('match_case', false)
+      storage.set_default('with_context', false)
+      storage.set_default('context_lines', 2)
+      storage.save
+    end
+  end
+  
+  Lucene::Config.use do |config| 
+    config[:store_on_file] = true 
+    config[:storage_path]  = ""
+    config[:id_field]      = :id
+  end
+  
+  
+  def self.project_refresh_task_type
+    LuceneRefresh
+  end
+  
+  def self.indexes
+    @indexes ||= {}
+  end
+end
+
+

data/plugins/project_search/lib/project_search/binary_data_detector.rb

@@ -0,0 +1,46 @@
+
+class ProjectSearch
+  # This class discriminates between binary and textual data. 
+  class BinaryDataDetector
+    # Is the data binary?
+    #
+    # @param [String] data 
+    def self.binary?(data)
+      not textual?(data)
+    end
+    
+    # Is the data plain text?
+    #
+    # @param [String] data 
+    def self.textual?(data)
+      found_good_byte = false
+      data.each_byte do |b|
+        return false if bad_byte?(b)
+        found_good_byte = found_good_byte || good_byte?(b)
+      end
+      found_good_byte
+    end
+    
+    INDIVIDUAL_GOOD_BYTES = [9, 10, 13]
+    
+    # At least one of these good bytes must be found for the text to be 
+    # discriminated as plain text.
+    #
+    # @param [Fixnum] byte
+    def self.good_byte?(byte)
+      (byte >= 32 and byte <= 255) or INDIVIDUAL_GOOD_BYTES.include?(byte)
+    end
+    
+    INDIVIDUAL_BAD_BYTES = [0, 6, 14]
+    
+    # If any of these bytes are found then we immediately discriminate the data 
+    # as binary.
+    #
+    # @param [Fixnum] byte
+    def self.bad_byte?(byte)
+      (byte >= 14 and byte <= 31) or INDIVIDUAL_BAD_BYTES.include?(byte)
+    end
+  end
+end
+
+

data/plugins/project_search/lib/project_search/commands.rb

@@ -0,0 +1,62 @@
+
+class ProjectSearch
+  class WordSearchCommand < Redcar::Command
+    sensitize :open_project
+    
+    def find_open_instance
+      all_tabs = Redcar.app.focussed_window.notebooks.map { |nb| nb.tabs }.flatten
+      all_tabs.find do |t|
+        t.is_a?(Redcar::HtmlTab) && t.title == ProjectSearch::WordSearchController::TITLE
+      end
+    end
+    
+    def execute
+      if project = Redcar::Project::Manager.focussed_project
+        if (tab = find_open_instance)
+          tab.html_view.refresh
+          tab.focus
+        else
+          index = ProjectSearch.indexes[project.path]
+          if index and index.has_content?
+            tab = win.new_tab(Redcar::HtmlTab)
+            tab.html_view.controller = ProjectSearch::WordSearchController.new
+            tab.focus
+          else
+            Redcar::Application::Dialog.message_box("Your project is still being indexed.", :type => :error)
+          end
+        end
+      else
+        Redcar::Application::Dialog.message_box("You need an open project to be able to use Find In Project!", :type => :error)
+      end
+      return
+    end
+  end
+  
+  class RegexSearchCommand < Redcar::Command
+    sensitize :open_project
+    
+    def execute
+      if Redcar::Project::Manager.focussed_project
+        if (tab = find_open_instance)
+          tab.html_view.controller = tab.html_view.controller # refresh
+        else
+          tab = win.new_tab(Redcar::HtmlTab)
+          tab.html_view.controller = ProjectSearch::RegexSearchController.new
+        end
+        tab.focus
+      else
+        # warning
+        Redcar::Application::Dialog.message_box("You need an open project to be able to use Find In Project!", :type => :error)
+      end
+    end
+
+    private
+
+    def find_open_instance
+      all_tabs = Redcar.app.focussed_window.notebooks.map { |nb| nb.tabs }.flatten
+      all_tabs.find do |t|
+        t.is_a?(Redcar::HtmlTab) && t.title == ProjectSearch::RegexSearchController.new.title
+      end
+    end
+  end  
+end

data/plugins/project_search/lib/project_search/hit.rb

@@ -0,0 +1,17 @@
+
+class ProjectSearch
+  class Hit
+    attr_reader :file, :line_num, :pre_context, :post_context
+    
+    def initialize(file, line_num, line, regex, 
+        pre_context, post_context)
+      @file, @line_num, @line, @regex = file, line_num, line, regex
+      @pre_context = pre_context
+      @post_context = post_context
+    end
+    
+    def line(start_with=nil, end_with=nil)
+      @line.gsub(@regex) { start_with.to_s + $& + end_with.to_s }
+    end
+  end
+end

data/plugins/project_search/lib/project_search/lucene_index.rb

@@ -0,0 +1,64 @@
+
+class ProjectSearch
+  class LuceneIndex
+    attr_accessor :last_updated, :lucene_index
+    
+    def initialize(project)
+      @project     = project
+      @has_content = false
+      load
+    end
+    
+    def timestamp_file_path
+      File.join(@project.config_dir, 'lucene_last_updated')
+    end
+    
+    def load
+      @last_updated = Time.at(0)
+      if File.exist?(timestamp_file_path)
+        @last_updated = Time.at(File.read(timestamp_file_path).chomp.to_i)
+        @has_content = true
+      end
+    end
+    
+    def dump
+      File.open(timestamp_file_path, "w") do |fout|
+        fout.puts(last_updated.to_i.to_s)
+      end
+    end
+    
+    def has_content?
+      @has_content
+    end
+    
+    def update
+      changed_files = @project.file_list.changed_since(last_updated)
+      @last_updated = Time.now
+      changed_files.reject! do |fn, ts|
+        fn.index(@project.config_dir)
+      end
+      Lucene::Transaction.run do 
+        @lucene_index ||= Lucene::Index.new(File.join(@project.config_dir, "lucene")) 
+        begin
+          @lucene_index.field_infos[:contents][:store] = true 
+          @lucene_index.field_infos[:contents][:tokenized] = true
          changed_files.each do |fn, ts|
+            unless File.basename(fn)[0..0] == "." or fn.include?(".git")
+              contents = File.read(fn)
+              unless BinaryDataDetector.binary?(contents[0..200])
+                adjusted_contents = contents.gsub(/\.([^\s])/, '. \1')
+                @lucene_index << { :id => fn, :contents => adjusted_contents }
+              end
+            end
+          end
+          @lucene_index.commit
+          @has_content = true
+        rescue => e
+          puts e.message
+          puts e.backtrace
+        end
+      end
+      dump
+    end
+    
+  end
+end

data/plugins/project_search/lib/project_search/lucene_refresh.rb

@@ -0,0 +1,22 @@
+
+class ProjectSearch
+  
+  class LuceneRefresh < Redcar::Task
+    def initialize(project)
+      @project     = project
+    end
+    
+    def description
+      "#{@project.path}: refresh index"
+    end
+    
+    def execute
+      return if @project.remote?
+      unless index = ProjectSearch.indexes[@project.path]
+        index = ProjectSearch::LuceneIndex.new(@project)
+        ProjectSearch.indexes[@project.path] = index
+      end
+      index.update
+    end
+  end
+end

data/plugins/project_search/lib/project_search/project.rb

@@ -0,0 +1,14 @@
+
+module Redcar
+  class Project
+    def search(query, options)
+      options ||= {}
+      
+      strategy   = (options[:regex] || false) ? RegexSearch : WordSearch
+      match_case = options[:match_case] || true
+      context    = options[:context]    || 0
+      
+      strategy.new(ProjectSearch.indexes[self], query, match_case, context)
+    end
+  end
+end

data/plugins/project_search/lib/project_search/query.rb

@@ -0,0 +1,29 @@
+
+class ProjectSearch
+  class Query
+    attr_reader :query_string
+    
+    # Construct a 
+    #
+    #
+    def initialize(project, query_string, regex, match_case, context)
+      @project      = project
+      @query_string = query_string
+      @regex        = regex
+      @match_case   = match_case
+      @context      = context
+    end
+    
+    def match_case?
+      @match_case
+    end
+    
+    def context
+      @context
+    end
+    
+    def regex?
+      @regex
+    end
+  end
+end