redcar 0.3.4.3 → 0.3.5

data/plugins/project/features/open_directory_tree.feature

@@ -12,6 +12,14 @@ Feature: Open directory tree
     When I open a directory
     Then I should see "core,application,tree" in the tree
   
-  
-  
-  
+  Scenario: Title of window reflects open project
+    Given I will choose "plugins/project/spec/fixtures/myproject" from the "open_directory" dialog
+    When I open a directory
+    Then the window should have title "myproject"
+
+  Scenario: Title of window returns to "Redcar" if directory is closed
+    Given I will choose "plugins/project/spec/fixtures/myproject" from the "open_directory" dialog
+    When I open a directory
+    Then the window should have title "myproject"
+    When I close the directory
+    Then the window should have title "Redcar"

data/plugins/project/features/refresh_directory_tree.feature

@@ -24,7 +24,7 @@ Feature: Refresh directory tree
     And I should not see "testyfile.txt" in the tree
     When I touch the file "./testyfile.txt"
     When I open a new window
-    And I focus the window "Redcar" through the gui
+    And I focus the window "redcar" through the gui
     Then I should see "bin,config,lib,plugins,testyfile.txt" in the tree
     
   Scenario: Refreshing the tree leaves rows expanded as they were before
@@ -35,3 +35,9 @@ Feature: Refresh directory tree
     And I refresh the directory tree
     Then I should see "bin,config,lib,freebase2,plugins" in the tree
   
+  Scenario: Tree is moved
+    Given I will choose "plugins/project/spec/fixtures/myproject" from the "open_directory" dialog
+    When I open a directory
+    And I move the myproject fixture away
+    And I refresh the directory tree
+    Then I should not see "lib" in the tree  

data/plugins/project/features/step_definitions/directory_steps.rb

@@ -3,6 +3,16 @@ When /I open a directory/ do
   Redcar::Project::DirectoryOpenCommand.new.run
 end
 
+When /I close the directory/ do
+  Redcar::Project::DirectoryCloseCommand.new.run
+end
+
 When /^I refresh the directory tree$/ do
-  Redcar::Project.refresh_tree(Redcar.app.focussed_window)
+  Redcar::Project::Manager.focussed_project.refresh
 end
+
+When /^I move the myproject fixture away$/ do
+  FileUtils.mv("plugins/project/spec/fixtures/myproject",
+               "plugins/project/spec/fixtures/myproject.bak")
+  @put_myproject_fixture_back = true
+end

data/plugins/project/features/step_definitions/file_steps.rb

@@ -20,6 +20,10 @@ When /^I touch the file "([^\"]*)"$/ do |fn|
   add_test_file(fn)
 end
 
+When /^I put "([^\"]*)" into the file "([^\"]*)"$/ do |contents, path|
+  File.open(path, "w") {|fout| fout.print contents }
+end
+
 When /^I save the tab as$/ do
   Redcar::Project::FileSaveAsCommand.new.run
 end
@@ -28,6 +32,12 @@ Then /^the file "([^\"]*)" should contain "([^\"]*)"$/ do |arg1, arg2|
   File.read(arg1).should == arg2
 end
 
+When /^I put a lot of lines into the file "([^\"]*)"$/ do |file|
+  File.open(file, "w") do |f|
+    200.times { |i| f.puts (i*20).to_s }
+  end
+end
+
 def add_test_file(fn)
   (@test_files ||= []) << File.expand_path(fn)
 end

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

@@ -1,7 +1,12 @@
 RequireSupportFiles File.dirname(__FILE__) + "/../../../edit_view/features/"
 
 def reset_project_fixtures
-  fixtures_path = File.expand_path(File.dirname(__FILE__) + "/../fixtures")
+  if @put_myproject_fixture_back
+    @put_myproject_fixture_back = nil
+    FileUtils.mv("plugins/project/spec/fixtures/myproject.bak",
+                 "plugins/project/spec/fixtures/myproject")
+  end
+  fixtures_path = File.expand_path(File.dirname(__FILE__) + "/../../spec/fixtures")
   File.open(fixtures_path + "/winter.txt", "w") {|f| f.print "Wintersmith" }
   FileUtils.rm_rf(fixtures_path + "/winter2.txt")
 end

data/plugins/project/features/watch_for_modified_files.feature

@@ -0,0 +1,79 @@
+Feature: Watch for modified files
+  If an open file has changed on disc since the last time the user looked at it,
+  then reload the contents. Alert the user if they have made modifications.
+  
+  Background:
+    Given I will choose "plugins/project/spec/fixtures/winter.txt" from the "open_file" dialog
+    When I open a file
+  
+  Scenario: Without modifications
+    Then there should be one edit tab
+    And I should see "Wintersmith" in the edit tab
+    When I open a new edit tab
+    And I wait "2" seconds
+    And I put "Summer" into the file "plugins/project/spec/fixtures/winter.txt"
+    And I close the focussed tab
+    Then I should see "Summer" in the edit tab
+
+  Scenario: With modifications, reloading from disc
+    Then there should be one edit tab
+    And I should see "Wintersmith" in the edit tab
+    And I replace the contents with "FOFOOF"
+    When I open a new edit tab
+    And I wait "2" seconds
+    And I put "Summer" into the file "plugins/project/spec/fixtures/winter.txt"
+    Given I will choose "yes" from the "message_box" dialog
+    And I close the focussed tab
+    Then I should see "Summer" in the edit tab
+  
+  Scenario: With modifications, keeping modified version
+    Then there should be one edit tab
+    And I should see "Wintersmith" in the edit tab
+    And I replace the contents with "Newton"
+    When I open a new edit tab
+    And I wait "2" seconds
+    And I put "Summer" into the file "plugins/project/spec/fixtures/winter.txt"
+    Given I will choose "no" from the "message_box" dialog
+    And I close the focussed tab
+    Then I should see "Newton" in the edit tab
+  
+  Scenario: With modifications, keeping modified version, twice
+    Then there should be one edit tab
+    And I should see "Wintersmith" in the edit tab
+    And I replace the contents with "Newton"
+    When I open a new edit tab
+    And I wait "2" seconds
+    And I put "Summer" into the file "plugins/project/spec/fixtures/winter.txt"
+    Given I will choose "no" from the "message_box" dialog
+    And I close the focussed tab
+    Then I should see "Newton" in the edit tab
+    When I open a new edit tab
+    Then I should not see a "message_box" dialog for the rest of the feature
+    And I close the focussed tab
+  
+  Scenario: Keep in the same position in the file when reloading
+    Given I close the focussed tab
+    And I put a lot of lines into the file "plugins/project/spec/fixtures/winter.txt"
+    When I open a file
+    And I move to line 100
+    Then there should be one edit tab
+    When I open a new edit tab
+    And I wait "2" seconds
+    And I put a lot of lines into the file "plugins/project/spec/fixtures/winter.txt"
+    And I close the focussed tab
+    Then the cursor should be on line 100
+    
+  Scenario: Move to the top if the line you were on is no longer there
+    Given I close the focussed tab
+    And I put a lot of lines into the file "plugins/project/spec/fixtures/winter.txt"
+    When I open a file
+    And I move to line 100
+    Then there should be one edit tab
+    When I open a new edit tab
+    And I wait "2" seconds
+    And I put "Summer" into the file "plugins/project/spec/fixtures/winter.txt"
+    And I close the focussed tab
+    Then the cursor should be on line 0
+    
+  
+  

data/plugins/project/lib/project.rb

@@ -1,360 +1,126 @@
 require 'drb/drb'
 
-require "project/project_command"
-require "project/file_mirror"
-require "project/find_file_dialog"
+require "project/commands"
 require "project/dir_mirror"
 require "project/dir_controller"
 require "project/drb_service"
+require "project/file_list"
+require "project/file_mirror"
+require "project/find_file_dialog"
+require "project/manager"
 require "project/recent_directories"
 
 module Redcar
   class Project
     RECENT_FILES_LENGTH = 20
-
-    # this will restore open files unless other files or dirs were passed
-    # as command line parameters
-    def self.start
-      restore_last_session unless handle_startup_arguments
-      init_current_files_hooks
-      init_window_closed_hooks
-      init_drb_listener
-    end
-    
-    def self.init_window_closed_hooks
-      Redcar.app.add_listener(:window_about_to_close) do |win|
-        self.save_file_list win
-      end
-    end
-    
-    def self.init_drb_listener
-      return if ARGV.include?("--multiple-instance")
-      @drb_service = DrbService.new
-    end
-    
-    def self.storage
-      @storage ||= Plugin::Storage.new('project_plugin')
-    end
-    
-    def self.sensitivities
-      [ @open_project_sensitivity = 
-          Sensitivity.new(:open_project, Redcar.app, false, [:focussed_window]) do
-            if win = Redcar.app.focussed_window
-              win.treebook.trees.detect {|t| t.tree_mirror.is_a?(DirMirror) }
-            end
-          end
-      ]
-    end
-    
-    class << self
-      attr_reader :open_project_sensitivity
-    end
   
-    def self.filter_path
-      if Redcar.app.focussed_notebook_tab
-        if mirror = EditView.focussed_document_mirror and mirror.is_a?(FileMirror)
-          dir = File.dirname(mirror.path)
-          return dir
-        end
-      end      
-      Project.storage['last_dir'] || File.expand_path(Dir.pwd)
-    end
-  
-    def self.window_trees
-      @window_trees ||= {}
-    end
-  
-    def self.open_tree(win, tree)
-      if window_trees[win]
-        old_tree = window_trees[win]
-        set_tree(win, tree)
-        win.treebook.remove_tree(old_tree)
-      else
-        set_tree(win, tree)
-      end
-      Project.open_project_sensitivity.recompute
-    end
-
-    # Close the Directory Tree for the given window, if there 
-    # is one.
-    def self.close_tree(win)
-      win.treebook.remove_tree(window_trees[win])
-      Project.open_project_sensitivity.recompute
-    end
-    
-    # Refresh the DirMirror Tree for the given Window, if 
-    # there is one.
-    def self.refresh_tree(win)
-      if tree = window_trees[win]
-        tree.refresh
-      end
-    end
-    
-    # Finds an EditTab with a mirror for the given path.
-    #
-    # @param [String] path  the path of the file being edited
-    # @return [EditTab, nil] the EditTab that is editing it, or nil
-    def self.open_file_tab(path)
-      path = File.expand_path(path)
-      all_tabs = Redcar.app.windows.map {|win| win.notebooks}.flatten.map {|nb| nb.tabs }.flatten
-      all_tabs.find do |t| 
-        t.is_a?(Redcar::EditTab) and 
-        t.edit_view.document.mirror and 
-        t.edit_view.document.mirror.is_a?(FileMirror) and 
-        File.expand_path(t.edit_view.document.mirror.path) == path 
-      end
-    end
-    
-    # Opens a new EditTab with a FileMirror for the given path.
-    #
-    # @path  [String] path the path of the file to be edited
-    # @param [Window] win  the Window to open the File in
-    def self.open_file(path, win = Redcar.app.focussed_window)
-      win ||= Redcar.app.new_window # in case there's not one open
-      tab = win.new_tab(Redcar::EditTab)
-      mirror = FileMirror.new(path)
-      tab.edit_view.document.mirror = mirror
-      tab.edit_view.reset_undo
-      tab.focus
+    def self.window_projects
+      @window_projects ||= {}
     end
     
-    # Opens a new Tree with a DirMirror and DirController for the given
-    # path.
-    #
-    # @param [String] path  the path of the directory to view
-    # @param [Window] win  the Window to open the Tree in
-    def self.open_dir(path, win = Redcar.app.focussed_window)
+    attr_reader :window, :tree, :path
+
+    def initialize(path)
       path = File.expand_path(path)
       if !File.directory?(path)
       	raise 'Not a directory: ' + path
       end
-      win ||= Redcar.app.new_window # case none open
-      tree = Tree.new(Project::DirMirror.new(path),
-                      Project::DirController.new)
-      Project.open_tree(win, tree)
-      # adds the directory path to the RecentDirectories plugin
-      RecentDirectories.store_path(path)
-      storage['last_open_dir'] = path
+      @path   = path
+      @tree   = Tree.new(Project::DirMirror.new(path),
+                         Project::DirController.new)
+      @window = nil
+      file_list_resource.compute
     end
     
-    # A list of files previously opened in this session for a given directory path
-    #
-    # @param  [String] path   a directory path
-    # @return [Array<String>] an array of paths
-    def self.recent_files_for(path)
-      (@recent_files ||= Hash.new {|h,k| h[k] = [] })[path]
+    def inspect
+      "<Project #{path}>"
     end
     
-    # The directory path of the currently focussed project, or nil if
-    # there is no directory open in the focussed window.
-    #
-    # @return [String, nil]
-    def self.focussed_project_path
-      if tree = focussed_project_tree
-        tree.tree_mirror.path
+    def open(win)
+      @window = win
+      if current_project = Project.window_projects[window]
+        current_project.close
       end
+      window.treebook.add_tree(@tree)
+      window.title = File.basename(@tree.tree_mirror.path)
+      Manager.open_project_sensitivity.recompute
+      RecentDirectories.store_path(path)
+      Manager.storage['last_open_dir'] = path
+      Project.window_projects[window] = self
     end
     
-    # The Tree object for the currently focussed project tree, or nil
-    # if there is no directory open in the focussed window.
-    def self.focussed_project_tree
-      Redcar.app.focussed_window.treebook.trees.detect {|t| t.tree_mirror.is_a?(Project::DirMirror)}
-    end
-    
-    private
-    
-    # restores the directory/files in the last open window
-    def self.restore_last_session
-      if path = storage['last_open_dir']
-        open_dir(path)
-      end
-      
-      if files = Project.storage['files_open_last_session']
-        files.each do |path|
-          open_file(path)
-        end
-      end
-    end
-        
-    # saves away a list of the currently open files in
-    # @param [win]
-    def self.save_file_list(win)
-      # create a list of open files
-      file_list = []
-      win.notebooks[0].tabs.each do |tab|
-        if tab.document && tab.document.path
-          file_list << tab.document.path
-        end
-      end
-      Project.storage['files_open_last_session'] = file_list      
+    def close
+      window.treebook.remove_tree(@tree)
+      Project.window_projects.delete(window)
+      window.title = Window::DEFAULT_TITLE
+      Manager.open_project_sensitivity.recompute
     end
     
-    # handles files and/or dirs passed as command line arguments
-    def self.handle_startup_arguments
-      if ARGV
-        args = ARGV.dup
-        dir_args  = args.select {|path| File.directory?(path) }
-        args -= dir_args
-        file_args = args.select {|path| !path.start_with?('--') }
-        
-        dir_args.each {|path| open_dir(path) }
-        file_args.each {|path| open_file(path) }
-        return (dir_args.any? or file_args.any?)
-      end
+    # Refresh the DirMirror Tree for the given Window, if 
+    # there is one.
+    def refresh
+      @tree.refresh
+      file_list_resource.compute
     end
     
-    # Attaches a new listener to tab focus change events, so we can 
-    # keep the current_files list.
-    def self.init_current_files_hooks
-      Redcar.app.add_listener(:tab_focussed) do |tab|
-        if tab and tab.document_mirror.respond_to?(:path)
-          add_to_recent_files_for(Project.focussed_project_path, tab.document_mirror.path)
-        end
-      end
-      attach_app_listeners
+    def contains_path?(path)
+      File.expand_path(path) =~ /^#{@path}/
     end
     
-    def self.attach_app_listeners
-      Redcar.app.add_listener(:lost_focus) do
-        FindFileDialog.clear
-      end
-      
-      Redcar.app.add_listener(:focussed) do
-        window_trees.values.each {|tree| tree.refresh }
-      end
+    # A list of files previously opened in this session for this project
+    #
+    # @return [Array<String>] an array of paths
+    def recent_files
+      @recent_files ||= []
     end
     
-    def self.add_to_recent_files_for(directory_path, new_file)
-      new_file = File.expand_path(new_file) 
-      if recent_files_for(directory_path).include?(new_file)
-        recent_files_for(directory_path).delete(new_file)
+    def add_to_recent_files(new_file)
+      new_file = File.expand_path(new_file)
+      if recent_files.include?(new_file)
+        recent_files.delete(new_file)
       end
-      recent_files_for(directory_path).unshift(new_file)
-      if recent_files_for(directory_path).length > RECENT_FILES_LENGTH
-        recent_files_for(directory_path).pop
+      recent_files << new_file
+      if recent_files.length > RECENT_FILES_LENGTH
+        recent_files.shift
       end
     end
     
-    def self.set_tree(win, tree)
-      window_trees[win] = tree
-      win.treebook.add_tree(tree)
+    def file_list
+      @file_list ||= FileList.new(path)
     end
     
-    class FileOpenCommand < Command
-      
-      def initialize(path = nil)
-        @path = path
-      end
-    
-      def execute
-        path = get_path
-        if path
-          if already_open_tab = Project.open_file_tab(path)
-            already_open_tab.focus
-          else
-            Project.open_file(path)
-          end
-        end
-      end
-      
-      private
-      
-      def get_path
-        @path || begin
-          if path = Application::Dialog.open_file(win, :filter_path => Project.filter_path)
-            Project.storage['last_dir'] = File.dirname(File.expand_path(path))
-            path
-          end
-        end
+    def file_list_resource
+      @resource ||= Resource.new("refresh file list for #{@path}") do
+        file_list.update
+        send_refresh_to_plugins
       end
     end
     
-    class FileSaveCommand < EditTabCommand
-
-      def execute
-        tab = win.focussed_notebook.focussed_tab
-        if tab.edit_view.document.mirror
-          tab.edit_view.document.save!
-        else
-          FileSaveAsCommand.new.run
-        end
-      end
+    def refresh_modified_file(path)
+      file_list.update(path)
+      @tree.refresh
+      send_refresh_to_plugins
     end
-    
-    class FileSaveAsCommand < EditTabCommand
       
-      def initialize(path = nil)
-        @path = path
-      end
-
-      def execute
-        tab = win.focussed_notebook.focussed_tab
-        path = get_path
-        if path
-          contents = tab.edit_view.document.to_s
-          new_mirror = FileMirror.new(path)
-          new_mirror.commit(contents)
-          tab.edit_view.document.mirror = new_mirror
-          Project.refresh_tree(win)
-        end
-      end
-      
-      private
-      def get_path
-        @path || begin
-          if path = Application::Dialog.save_file(win, :filter_path => Project.filter_path)
-            Project.storage['last_dir'] = File.dirname(File.expand_path(path))
-            path
-          end
-        end
-      end
+    def all_files
+      file_list.all_files
     end
     
-    class DirectoryOpenCommand < Command
-          
-      def initialize(path=nil)
-        @path = path
-      end
-      
-      def execute
-        if path = get_path
-          Project.open_dir(path, win)
-        end
-      end
-      
-      private
-
-      def get_path
-        @path || begin
-          if path = Application::Dialog.open_directory(win, :filter_path => Project.filter_path)
-            Project.storage['last_dir'] = File.dirname(File.expand_path(path))
-            path
-          end
-        end
-      end
-    end
-    
-    class DirectoryCloseCommand < ProjectCommand
-
-      def execute
-        Project.close_tree(win)
+    def send_refresh_to_plugins
+      Redcar.plugin_manager.objects_implementing(:project_refresh_task_type).each do |object|
+        Redcar.app.task_queue.submit(object.project_refresh_task_type.new(self))
       end
     end
     
-    class RefreshDirectoryCommand < ProjectCommand
-    
-      def execute
-        Project.refresh_tree(win)
-      end
+    def lost_application_focus
+      @lost_application_focus = true
     end
     
-    class FindFileCommand < ProjectCommand
-     
-      def execute
-        dialog = FindFileDialog.new
-        dialog.open
+    def gained_focus
+      if @lost_application_focus
+        refresh
       end
+      @lost_application_focus = nil
     end
-    
   end
 end