redcar-dev 0.12.17dev

data/plugins/project/lib/project/dir_mirror.rb

@@ -0,0 +1,176 @@
+
+module Redcar
+  class Project
+    class DirMirror
+      class << self
+        attr_accessor :show_hidden_files
+        
+        def show_hidden_files?
+          show_hidden_files
+        end
+      end
+        
+      include Redcar::Tree::Mirror
+      attr_reader :path, :adapter
+      
+      # @param [String] a path to a directory
+      def initialize(path, adapter=Adapters::Local.new)
+        @adapter = adapter
+        @changed = true
+        @path = path
+      end
+      
+      def title
+        File.basename(@path) + "/"
+      end
+      
+      # Does the directory exist?
+      def exists?
+        @adapter.exists?(@path) && @adapter.directory?(@path)
+      end
+      
+      # Have the toplevel nodes changed?
+      #
+      # @return [Boolean]
+      def changed?
+        @changed
+      end
+      
+      # Drag and drop is allowed in Dir trees
+      def drag_and_drop?
+        true
+      end
+      
+      # The files and directories in the top of the directory.
+      def top
+        @changed = false
+        Node.create_all_from_path(@adapter, @path)
+      end
+      
+      # We specify a :file data type to take advantage of OS integration.
+      def data_type
+        :file
+      end
+      
+      # Return the Node for this path.
+      #
+      # @return [Node]
+      def from_data(path)
+        Node.create_from_path(@adapter, {:fullname => path})
+      end
+      
+      # Turn the nodes into data.
+      def to_data(nodes)
+        nodes.map {|node| node.path }
+      end
+      
+      def refresh_operation(tree)
+        @adapter.refresh_operation(tree) do
+          yield
+        end
+      end
+      
+      class Node
+        include Redcar::Tree::Mirror::NodeMirror
+
+        attr_reader :path, :adapter
+        attr_accessor :type, :is_empty_directory
+
+        def self.create_all_from_path(adapter, path)
+          fs = adapter.fetch_contents(path)
+          fs.reject! { |f| [".", ".."].include?(File.basename(f[:fullname])) }
+          unless DirMirror.show_hidden_files?
+            fs.reject! { |f| f[:type] == :file and Project::FileList.hide_file?(f[:fullname]) }
+            fs.reject! { |f| f[:type] == :dir and Project::FileList.hide_directory? f[:fullname] }
+          end
+          fs.sort_by do |f|
+            File.basename(f[:fullname]).downcase
+          end.sort_by do |f|
+            f[:type] == :dir ? -1 : 1
+          end.map {|f| create_from_path(adapter, f) }
+        end
+        
+        def self.create_from_path(adapter, f)
+          if result = cache[f[:fullname]]
+            result.type               = f[:type]
+            result.is_empty_directory = f[:empty]
+            result
+          else
+            cache[f[:fullname]] = Node.new(adapter, f[:fullname], f[:type], f[:empty])
+          end
+        end
+
+        def self.cache
+          @cache ||= {}
+        end
+        
+        def initialize(adapter, path, type, is_empty_directory)
+          @adapter            = adapter
+          @path               = path
+          @type               = type
+          @is_empty_directory = is_empty_directory
+        end
+        
+        def text
+          File.basename(@path)
+        end
+        
+        def icon
+          case @type
+          when :file
+            key = text.split('.').last.split(//).first.downcase
+            if key =~ /[b-z]/
+              :"document_attribute_#{key}"
+            elsif key == 'a'
+              :document_attribute
+            else
+              :document
+            end
+          when :dir
+            :blue_folder
+          end
+        end
+
+        def leaf?
+          file?
+        end
+        
+        def file?
+          @type == :file
+        end
+        
+        def directory?
+          @type == :dir
+        end
+        
+        def parent_dir
+          File.dirname(@path)
+        end
+        
+        def directory
+          directory? ? @path : File.dirname(@path)
+        end
+        
+        def children
+          if file? or @is_empty_directory
+            []
+          else
+            Node.create_all_from_path(adapter, @path)
+          end
+        end
+
+        def children?
+          !file? and !@is_empty_directory
+        end
+        
+        def tooltip_text
+          File.basename(@path)
+        end
+        
+        def inspect
+          "#<Project::DirMirror::Node path=#{path}>"
+        end
+      end
+    end
+  end
+end

data/plugins/project/lib/project/drb_service.rb

@@ -0,0 +1,86 @@
+module Redcar
+  class Project
+    class DrbService
+      def initialize
+        address = "druby://127.0.0.1:#{Redcar.drb_port}"
+        Redcar.log.benchmark("start drb service") do
+          @drb = DRb.start_service(address, self)
+        end
+      rescue Errno::EADDRINUSE => e
+        puts 'warning--not starting listener (perhaps theres another Redcar already open?)' + e + ' ' + address
+      end
+
+      def open_item_drb(full_path, untitled = false, wait = false)
+        puts %{drb opening #{"untitled" if untitled} #{full_path}} if $VERBOSE
+        if File.directory? full_path
+          Swt.sync_exec { open_directory(full_path) }
+        elsif full_path == 'just_bring_to_front'
+          Swt.sync_exec { bring_to_front }
+        elsif File.file?(full_path)
+          open_file(full_path, untitled, wait)
+        end
+        'ok'
+      rescue Exception => e
+        puts 'drb got exception:' + e.class + " " + e.message, e.backtrace
+        raise e
+      end
+
+      # Opens the specified directory in a new window, if it was not
+      # already open. Brings the project's window to the front, if this
+      # directory is already opened. If the specified directory was the last open
+      # directory, restores the complete session.
+      def open_directory(full_path)
+        if Redcar.app.windows.empty? and Application.storage['last_open_dir'] == full_path
+          Project::Manager.restore_last_session
+        end
+
+        Redcar::Project.window_projects.each_pair do |window, project|
+          return bring_window_to_front(window) if project.path == full_path
+        end
+        Project::Manager.open_project_for_path(full_path)
+        bring_window_to_front
+      end
+
+      ## Focuses a Redcar window
+      def bring_to_front
+        Project::Manager.restore_last_session if Redcar.app.windows.empty?
+        bring_window_to_front
+      end
+      
+      def bring_window_to_front(win = Redcar.app.focussed_window)
+        unless Redcar.environment == :test
+          win.controller.bring_to_front
+        end
+      end
+
+      # Opens a file, optionally untitled, and waits for it to close, if requested
+      def open_file(file, untitled, wait)
+        file_open_block = Proc.new do
+          Project::Manager.restore_last_session if Redcar.app.windows.empty?
+          if untitled
+            Project::Manager.open_untitled_path(file)
+          else
+            Project::Manager.open_file(file)
+          end
+          bring_window_to_front
+        end
+        wait ? open_file_and_wait(&file_open_block) : Swt.sync_exec(&file_open_block)
+      end
+
+      def open_file_and_wait
+        semaphore = Mutex.new
+        handler = nil
+        tab = nil
+        Swt.sync_exec do
+          semaphore.lock
+          yield
+          tab = Redcar.app.focussed_window.focussed_notebook_tab
+          handler = tab.add_listener(:close) { semaphore.unlock }
+        end
+        Thread.new(tab, handler) do
+          semaphore.synchronize { tab.remove_listener(handler) }
+        end.join # Wait until the tab's close event was fired
+      end
+    end
+  end
+end

data/plugins/project/lib/project/file_list.rb

@@ -0,0 +1,164 @@
+module Redcar
+  class Project
+    class FileList
+      attr_reader :path
+    
+      def self.shared_storage
+        @shared_storage ||= begin
+          storage = Plugin::SharedStorage.new('shared__ignored_files')
+          storage.set_or_update_default('ignored_file_patterns', [/^\./, /\.rbc$/])
+          storage.set_or_update_default('not_hidden_files', ['.gitignore', '.gemtest'])
+          storage.set_or_update_default('ignored_directory_patterns', [/^\./, /^\.(git|yardoc|svn)$/])
+          storage.set_or_update_default('not_hidden_directories', ['.directory_that_should_not_be_hidden'])
+          storage.save
+        end
+      end
+
+      def self.hidden_files_pattern
+        ignored_file_patterns
+      end
+
+      def self.ignored_file_patterns
+        shared_storage['ignored_file_patterns']
+      end
+
+      def self.not_hidden_files
+        shared_storage['not_hidden_files']
+      end
+
+      def self.hide_file?(file)
+        file = File.basename(file)
+        return false if not_hidden_files.include?(file)
+        ignored_file_patterns.any? { |re| file =~ re }
+      end
+      
+      def self.ignored_directory_patterns
+        shared_storage['ignored_directory_patterns']
+      end
+
+      def self.not_hidden_directories
+        shared_storage['not_hidden_directories']
+      end
+
+      def self.hide_directory?(dir)
+        dir = File.basename(dir)
+        return false if not_hidden_directories.include?(dir)
+        ignored_directory_patterns.any? { |re| dir =~ re }
+      end
+      
+      def self.hide_file_path?(file_path)
+        basename = File.basename(file_path)
+        if ignored_file_patterns.any? { |re| basename =~ re } and
+          !not_hidden_files.include?(basename)
+          return true
+        end
+        
+        dirs = file_path.split("/")[0..-2]
+        if ignored_directory_patterns.any? { |re| dirs.any? { |dir| dir =~ re } }
+          return true
+        end
+        false
+      end
+      
+      # Adds a pattern to the ignored_file_patterns option
+      #
+      # @param [String] file_pattern pattern of the file
+      def self.add_hide_file_pattern(file_pattern)
+        shared_storage['ignored_file_patterns'] = shared_storage['ignored_file_patterns'] + [Regexp.new(file_pattern)]
+      end
+
+      # Adds a pattern to the ignored_directory_patterns option
+      #
+      # @param [String] directory_pattern pattern of the directory
+      def self.add_hide_directory_pattern(directory_pattern)
+        shared_storage['ignored_directory_patterns'] = shared_storage['ignored_directory_patterns'] + [Regexp.new(directory_pattern)]
+      end
+
+      def initialize(path)
+        @path = File.expand_path(path)
+        @files = {}
+      end
+      
+      def all_files
+        @files.keys
+      end
+      
+      def contains?(file)
+        @files[file]
+      end
+      
+      def update(paths=nil)
+        if paths
+          @files = @files.merge(find(*paths))
+        else
+          @files = find(path)
+        end
+      end
+      
+      def changed_since(time)
+        result = {}
+        @files.each do |file, mtime|
+          if mtime.to_i >= time.to_i - 1
+            result[file] = mtime
+          end
+        end
+        result
+      end
+      
+      def inspect
+        "#<FileList for #{path.inspect}: #{@files.size} files>"
+      end
+      
+      private
+      
+      def find(*paths)
+        files = {}
+        paths.collect!{|d| d.dup}
+        while file = paths.shift
+          begin
+            if File.symlink? file
+              real_file = File.expand_path(File.join("..", File.readlink(file)), file)
+              real_file = File.expand_path(File.join("..", File.readlink(real_file)), real_file) while File.symlink? real_file
+              stat = File.lstat(real_file)
+            else
+              stat = File.lstat(file)
+            end
+            
+            if stat.directory?
+              next if FileList.hide_directory?(file)
+            else
+              next if FileList.hide_file?(file)
+            end
+            
+            unless stat.directory?
+              files[file.dup] = stat.mtime
+            end
+            
+            next unless File.exist?(file)
+            
+            if stat.directory?
+              d = Dir.open(file)
+              begin
+                for f in d
+                  next if f == "." or f == ".."
+                  if File::ALT_SEPARATOR and file =~ /^(?:[\/\\]|[A-Za-z]:[\/\\]?)$/
+                    f = file + f
+                  elsif file == "/"
+                    f = "/" + f
+                  else
+                    f = File.join(file, f)
+                  end
+                  paths.unshift f.untaint
+                end
+              ensure
+                d.close
+              end
+            end
+          rescue Errno::ENOENT, Errno::EACCES
+          end
+        end
+        files
+      end
+    end
+  end
+end

data/plugins/project/lib/project/file_mirror.rb

@@ -0,0 +1,85 @@
+
+require "digest/sha1"
+
+module Redcar
+  class Project
+    # Represents a local file. Implements the EditView::Mirror interface so it
+    # can be used as a mirror for a Redcar::Document. This is how files are 
+    # loaded in Redcar. EditView contains a Document which contains a Mirror
+    # which reflects a file.
+    class FileMirror
+      include Redcar::Document::Mirror
+      
+      attr_reader :path, :adapter, :timestamp
+      
+      # @param [String] a path to a file
+      def initialize(path, adapter=Adapters::Local.new)
+        @path = path
+        @adapter = adapter
+      end
+      
+      # Load the contents of the file from disk
+      #
+      # @return [String]
+      def read
+        return "" unless exists?
+        contents = load_contents
+        @timestamp = @adapter.mtime(@path)
+        contents
+      end
+      
+      # Does the file exist?
+      #
+      # @return [Boolean]
+      def exists?
+        @adapter.exists?(@path)
+      end
+      
+      # Has the file changed since the last time it was read or commited?
+      # If it has never been read then this is true by default.
+      #
+      # @return [Boolean]
+      def changed?
+        begin
+          !@timestamp or @timestamp < @adapter.mtime(@path)
+        rescue Errno::ENOENT
+          false
+        end
+      end
+      
+      def changed_since?(time)
+        begin
+          !@timestamp or (!time and changed?) or (time and time < @adapter.mtime(@path))
+        rescue Errno::ENOENT
+          false
+        end
+      end
+      
+      # Save new file contents.
+      #
+      # @param [String] new contents
+      # @return [unspecified]
+      def commit(contents)
+        save_contents(contents)
+        @timestamp = @adapter.mtime(@path)
+      end
+      
+      # The filename.
+      #
+      # @return [String]
+      def title
+        @path.split(/\/|\\/).last
+      end
+      
+      private
+      
+      def load_contents
+        @adapter.load(@path)
+      end
+      
+      def save_contents(contents)
+        @adapter.save(@path, contents)
+      end
+    end
+  end
+end