redcar 0.3.6 → 0.3.7

data/plugins/edit_view_swt/lib/edit_view_swt.rb

@@ -211,6 +211,10 @@ module Redcar
       @mate_text.get_control.set_focus
     end
     
+    def is_current?
+      EditView.current == @mate_text.get_control
+    end
+    
     def has_focus?
       focus_control = ApplicationSWT.display.get_focus_control
       focus_control == @mate_text.get_control

data/plugins/html_view/assets/redcar.css

@@ -40,4 +40,5 @@ tr.error {
 
 tr.cancelled {
   background-color: #EEE;
-}
+}
+

data/plugins/html_view/lib/html_view.rb

@@ -3,6 +3,14 @@ require 'html_view/html_tab'
 
 module Redcar
   class HtmlView
+    def self.default_css_path
+      File.expand_path(File.join(Redcar.root, %w(plugins html_view assets redcar.css)))
+    end
+    
+    def self.jquery_path
+      File.expand_path(File.join(Redcar.root, %w(plugins html_view assets jquery-1.4.min.js)))
+    end
+    
     attr_reader :controller
   
     def initialize(html_tab)
@@ -18,13 +26,14 @@ module Redcar
       controller_action("index")
     end
     
-    def controller_action(action_name, path=nil)
-      action_method_arity = controller.method(action_name).arity
+    def controller_action(action_name, params=nil)
+      text = nil
       begin
+        action_method_arity = controller.method(action_name).arity
         text = if action_method_arity == 0
                  controller.send(action_name)
                elsif action_method_arity == 1
-                 controller.send(action_name, path)
+                 controller.send(action_name, params)
                end
       rescue => e
         text = <<-HTML
@@ -32,7 +41,11 @@ module Redcar
           #{e.message}
         HTML
       end
-      @html_tab.controller.browser.set_text(text + setup_javascript_listeners)
+      if text
+        unless @html_tab.controller.browser.disposed
+          @html_tab.controller.browser.set_text(text.to_s + setup_javascript_listeners)
+        end
+      end
     end
     
     def contents=(source)
@@ -45,7 +58,7 @@ module Redcar
       def function(args)
         func_name = args.to_a.first
         func_args = args.to_a.last.to_a
-        controller.send(func_name.to_sym, *func_args)
+        JSON(controller.send(func_name.to_sym, *func_args))
       end
       
       attr_accessor :controller
@@ -59,7 +72,7 @@ module Redcar
       (controller.methods - Object.new.methods).each do |method_name|
         method = []
         method << "  #{method_name.gsub(/_(\w)/) { |a| $1.upcase}}: function() {"
-        method << "    rubyCall(\"#{method_name}\", Array.prototype.slice.call(arguments));"
+        method << "    return eval(rubyCall(\"#{method_name}\", Array.prototype.slice.call(arguments)));"
         method << "  }"
         methods << method.join("\n")
       end

data/plugins/html_view/lib/html_view/html_tab.rb

@@ -13,8 +13,8 @@ module Redcar
       @html_view = HtmlView.new(self)
     end
     
-    def controller_action(action, path)
-      notify_listeners(:controller_action, action, path)
+    def controller_action(action, params)
+      notify_listeners(:controller_action, action, params)
     end
   end
 end

data/plugins/project/lib/project.rb

@@ -124,5 +124,16 @@ module Redcar
       end
       @lost_application_focus = nil
     end
+    
+    def config_dir
+      File.join(path, ".redcar")
+    end
+    
+    def config_file(name)
+      file_path = File.join(config_dir, name.to_s)
+      if File.exist?(file_path)
+        YAML.load(File.read(file_path))
+      end
+    end
   end
 end

data/plugins/project/lib/project/dir_controller.rb

@@ -2,13 +2,263 @@
 module Redcar
   class Project
     class DirController
-      def activated(node)
+      include Redcar::Tree::Controller
+      
+      def activated(tree, node)
         if node.leaf?
           FileOpenCommand.new(node.path).run
         end
       end
+      
+      class DragController
+        include Redcar::Tree::Controller::DragController
+        
+        attr_reader :tree
+        
+        def initialize(tree)
+          @tree = tree
+        end
+        
+        def reorderable?
+          false
+        end
+        
+        def can_drop?(nodes, target, position)
+          nodes.all? {|node| droppable?(node, target)}
+        end
+        
+        def do_drop(nodes, target, position)
+          paths = nodes.map {|node| node.path }
+          non_nested_paths = remove_nested_paths(paths)
+          non_nested_paths.each do |path|
+            dir = target ? target.directory : tree.tree_mirror.path
+            unless File.dirname(path) == dir
+              FileUtils.mv(path, dir)
+            end
+          end
+          tree.refresh
+        end
+        
+        private
+        
+        def droppable?(from_node, target_node)
+          # you can always drop into the top level of the tree
+          return true if target_node == nil
+          
+          # can't drop a file/dir onto itself
+          return false if from_node.path == target_node.path
+          
+          # can't drop a directory into its children
+          !child_of?(from_node.path, target_node.path)
+        end
+        
+        def child_of?(path, possible_child_path)
+          possible_child_path =~ /^#{Regexp.escape(path)}\//
+        end
+        
+        # Removes paths which are children of higher level paths also being
+        # dragged.
+        def remove_nested_paths(paths)
+          sorted = paths.sort
+          keep = [sorted.first]
+          sorted[1..-1].each do |path|
+            unless child_of?(keep.last, path)
+              keep << path
+            end
+          end
+          keep
+        end
+      end
+      
+      def drag_controller(tree)
+        DragController.new(tree)
+      end
+      
+      def right_click(tree, node)
+        controller = self
+        
+        menu = Menu::Builder.build do
+          item("New File")      { controller.new_file(tree, node) }
+          item("New Directory") { controller.new_dir(tree, node)  }
+          separator
+          if tree.selection.length > 1
+            dirs = tree.selection.map {|node| node.parent_dir }
+            if dirs.uniq.length == 1
+              item("Bulk Rename") { controller.rename(tree, node)   }
+            end
+          else
+            item("Rename")      { controller.rename(tree, node)   }
+          end
+          item("Delete")        { controller.delete(tree, node)   }
+          separator
+          if DirMirror.show_hidden_files?
+            item("Hide Hidden Files") do
+              DirMirror.show_hidden_files = false
+              tree.refresh
+            end
+          else
+            item("Show Hidden Files") do
+              DirMirror.show_hidden_files = true
+              tree.refresh
+            end
+          end
+        end
+        
+        Application::Dialog.popup_menu(menu, :pointer)
+      end
+      
+      def new_file(tree, node)
+        enclosing_dir = node ? node.directory : tree.tree_mirror.path
+        new_file_name = uniq_name(enclosing_dir, "New File")
+        new_file_path = File.join(enclosing_dir, new_file_name)
+        FileUtils.touch(new_file_path)
+        tree.refresh
+        tree.expand(node)
+        new_file_node = DirMirror::Node.create_from_path(new_file_path)
+        tree.edit(new_file_node)
+      end
+      
+      def new_dir(tree, node)
+        enclosing_dir = node ? node.directory : tree.tree_mirror.path
+        new_dir_name = uniq_name(enclosing_dir, "New Directory")
+        new_dir_path = File.join(enclosing_dir, new_dir_name)
+        FileUtils.mkdir(new_dir_path)
+        tree.refresh
+        tree.expand(node)
+        new_dir_node = DirMirror::Node.create_from_path(new_dir_path)
+        tree.edit(new_dir_node)
+      end
+      
+      def rename(tree, node)
+        nodes = tree.selection
+        if nodes.length == 1
+          single_rename(tree, node)
+        else
+          bulk_rename(tree, nodes)
+        end
+      end
+      
+      def single_rename(tree, node)
+        if node.text =~ /^(.*)\.[^\.]+$/
+          tree.edit(node, 0, $1.length)
+        else
+          tree.edit(node)
+        end
+      end
+      
+      def bulk_rename(tree, nodes)
+        tab = Redcar.app.focussed_window.new_tab(HtmlTab)
+        controller = BulkRenameController.new(tab, tree, nodes)
+        tab.html_view.controller = controller
+        tab.focus
+      end
+      
+      class BulkRenameController
+        attr_reader :pairs, :match_pattern, :replace_pattern
+        
+        def initialize(tab, tree, nodes)
+          @tab = tab
+          @tree = tree
+          @pairs = nodes.map {|node| [node, File.basename(node.path)] }
+          @match_pattern = ""
+          @replace_pattern = ""
+        end
+        
+        def title
+          "Bulk Rename"
+        end
+      
+        def index
+          rhtml = ERB.new(File.read(File.join(File.dirname(__FILE__), "..", "..", "views", "bulk_rename.html.erb")))
+          rhtml.result(binding)
+        end
+        
+        def refresh(new_match_pattern, new_replace_pattern)
+          begin
+            @match_pattern   = /#{new_match_pattern}/
+          rescue
+            return []
+          end
+          @replace_pattern = new_replace_pattern
+          result = @pairs.map do |node, _|
+            old_name = File.basename(node.path)
+            new_name = transform_name(old_name)
+            new_path = File.join(File.dirname(node.path), new_name)
+            conflicts = (File.exist?(new_path) and new_name != old_name)
+            legal     = (new_name != "" and legal_path?(new_path))
+            [new_name, conflicts, legal]
+          end
+          result
+        end
+        
+        def submit(params)
+          p [:submit, params]
+          @pairs.each do |node, _|
+            old_name = File.basename(node.path)
+            new_name = transform_name(old_name)
+            next if old_name == new_name
+            new_path = File.join(File.dirname(node.path), new_name)
+            FileUtils.mv(node.path, new_path)
+          end
+          @tab.close
+          @tree.refresh
+        end
+        
+        private
+        
+        def transform_name(old_name)
+          old_name.sub(match_pattern, replace_pattern)
+        end
+        
+        def legal_path?(path)
+          return true if File.exist?(path)
+          
+          begin
+            FileUtils.touch(path)
+            FileUtils.rm(path)
+            return true
+          rescue Errno::ENOENT
+            return false
+          end
+        end
+      end
+      
+      def delete(tree, _)
+        nodes = tree.selection
+        basenames = nodes.map {|node| File.basename(node.path) }
+        msg = "Really delete #{basenames.join(", ")}?"
+        result = Application::Dialog.message_box(msg, :type => :question, :buttons => :yes_no)
+        if result == :yes
+          nodes.each do |node|
+            FileUtils.rm_rf(node.path)
+          end
+          tree.refresh
+        end
+      end
+      
+      def edited(tree, node, text)
+        new_path = File.expand_path(File.join(File.dirname(node.path), text))
+        return if node.path == new_path
+        
+        FileUtils.mv(node.path, new_path)
+        tree.refresh
+        new_node = DirMirror::Node.create_from_path(new_path)
+        tree.select(new_node)
+      end
+      
+      private
+      
+      def uniq_name(path, name)
+        return name unless File.exist?(File.join(path, name))
+        i = 1
+        loop do
+          new_name = name + " #{i}"
+          return new_name unless File.exist?(File.join(path, new_name))
+          i += 1
+        end
+      end
     end
   end
 end
 
-    
+    

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

@@ -2,6 +2,14 @@
 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
       
@@ -23,22 +31,46 @@ module Redcar
         @changed
       end
       
-      # Get the top-level nodes
-      #
-      # @return [Array<Node>]
+      # 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(@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(path)
+      end
+      
+      # Turn the nodes into data.
+      def to_data(nodes)
+        nodes.map {|node| node.path }
+      end
+      
       class Node
-
         include Redcar::Tree::Mirror::NodeMirror
 
         attr_reader :path
 
         def self.create_all_from_path(path)
-          Dir[path + "/*"].sort_by do |fn|
+          fs = Dir.glob(path + "/*", File::FNM_DOTMATCH)
+          fs = fs.reject {|f| [".", ".."].include?(File.basename(f))}
+          unless DirMirror.show_hidden_files?
+            fs = fs.reject {|f| File.basename(f) =~ /^\./ }
+          end
+          fs.sort_by do |fn|
             File.basename(fn).downcase
           end.sort_by do |path|
             File.directory?(path) ? -1 : 1
@@ -70,9 +102,25 @@ module Redcar
         end
         
         def leaf?
+          file?
+        end
+        
+        def file?
           File.file?(@path)
         end
         
+        def directory?
+          File.directory?(@path)
+        end
+        
+        def parent_dir
+          File.dirname(@path)
+        end
+        
+        def directory
+          directory? ? @path : File.dirname(@path)
+        end
+        
         def children
           Node.create_all_from_path(@path)
         end