redcar-dev 0.12.17dev

data/plugins/project/lib/project/commands.rb

@@ -0,0 +1,449 @@
+module Redcar
+  class ProjectCommand < Command
+    sensitize :open_project
+
+    def project
+      Project::Manager.in_window(win)
+    end
+  end
+
+  class Project
+    class OpenFileCommand < Command
+      def initialize(path = nil, adapter = Adapters::Local.new)
+        @path = path
+        @adapter = adapter
+      end
+
+      def execute
+        path = get_path
+        if path
+          if File.readable? path
+            Manager.open_file(path, @adapter)
+          else
+            Application::Dialog.message_box(
+              "Can't read #{path}, you don't have the permissions.",
+              :type => :error,
+              :buttons => :ok
+            )
+          end
+        end
+      end
+
+      private
+
+      def get_path
+        @path || begin
+          if path = Application::Dialog.open_file(:filter_path => Manager.filter_path)
+            Manager.storage['last_dir'] = File.dirname(File.expand_path(path))
+            path
+          end
+        end
+      end
+    end
+
+    class FileReloadCommand < EditTabCommand
+      def initialize(path = nil, adapter = Adapters::Local.new)
+        @path = path
+      end
+
+      def execute
+        if tab.edit_view.document.modified?
+          result = Application::Dialog.message_box("This tab has unsaved changes. \n\nReload?",
+            :buttons => :yes_no_cancel)
+          case result
+          when :yes
+            tab.edit_view.document.update_from_mirror
+          when :no
+          when :cancel
+          end
+        else
+          tab.edit_view.document.update_from_mirror
+        end
+      end
+    end
+
+    class OpenRemoteSpeedbar < Redcar::Speedbar
+
+      class << self
+        attr_accessor :connection
+
+        def connections
+          ConnectionManager::ConnectionStore.new.connections
+        end
+
+        def connection_names
+          if connections && connections.any?
+            ['Select...', connections.map { |c| c.name }].flatten
+          end
+        end
+      end
+
+      def initialize
+        connection.items = self.class.connection_names
+      end
+
+      label :connection_label, 'Connect to:'
+      combo :connection
+
+      button :connect, "Connect", "Return" do
+        selected = self.class.connections.find { |c| c.name == connection.value }
+
+        Manager.connect_to_remote(selected[:protocol], selected[:host],
+          selected[:user], selected[:path], ConnectionManager::PrivateKeyStore.paths)
+      end
+
+      button :quick, "Quick Connection", "Ctrl+Q" do
+        @speedbar = QuickOpenRemoteSpeedbar.new
+        Redcar.app.focussed_window.open_speedbar(@speedbar)
+      end
+
+      button :manage, "Connections Manager", "Ctrl+M" do
+        Redcar.app.focussed_window.close_speedbar
+        Redcar::ConnectionManager::OpenCommand.new.run
+      end
+    end
+
+    class QuickOpenRemoteSpeedbar < Redcar::Speedbar
+      class << self
+        attr_accessor :host
+        attr_accessor :user
+        attr_accessor :password
+        attr_accessor :path
+        attr_accessor :protocol
+      end
+
+      combo :protocol, %w(SFTP FTP), 'SFTP'
+
+      label :host_label, "Host:"
+      textbox :host
+
+      label :user_label, "User:"
+      textbox :user
+
+      label :path_label, "Path:"
+      textbox :path
+
+      button :connect, "Connect", "Return" do
+        Manager.connect_to_remote(protocol.value, host.value, user.value,
+          path.value, ConnectionManager::PrivateKeyStore.paths)
+      end
+    end
+
+    #class OpenRemoteCommand < Command
+    #  def initialize(url=nil)
+    #    @url = url
+    #  end
+    #
+    #  def execute
+    #    unless @url
+    #      @speedbar = OpenRemoteSpeedbar.new
+    #      win.open_speedbar(@speedbar)
+    #    end
+    #  end
+    #end
+
+    class SaveFileCommand < EditTabCommand
+      def initialize(tab=nil)
+        @tab = tab
+      end
+
+      def execute
+        if tab.edit_view.document.mirror
+          path          = tab.edit_view.document.mirror.path
+          dir           = File.dirname(path)
+          writable_file = File.writable?(path)
+          writable_dir  = File.writable?(dir) # this method buggy in windows: http://redmine.ruby-lang.org/issues/4712
+          file_exists   = File.exist?(path)
+          can_write     = writable_file || (!file_exists && writable_dir)
+          if can_write
+            begin
+              tab.edit_view.document.save!
+              Project::Manager.refresh_modified_file(tab.edit_view.document.mirror.path)
+            rescue Errno::EACCES # windows
+              show_dialog = true
+            end
+          else
+            show_dialog = true
+          end
+
+          if show_dialog
+            Application::Dialog.message_box(
+              "Can't save #{tab.edit_view.document.mirror.path}, you don't have the permissions.",
+              :type => :error,
+              :buttons => :ok
+            )
+            result = false
+          end
+        else
+          result = SaveFileAsCommand.new.run
+        end
+        tab.update_for_file_changes
+        result ||= true
+        return result
+      end
+    end
+
+    class SaveFileAsCommand < EditTabCommand
+
+      def initialize(tab=nil, path=nil)
+        @tab  = tab
+        @path = path
+      end
+
+      def execute
+        path = get_path
+        if path
+          if File.exists?(path) ? File.writable?(path) : File.writable?(File.dirname(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::Manager.refresh_modified_file(tab.edit_view.document.mirror.path)
+          else
+            Application::Dialog.message_box(
+              "Can't save #{path}, you don't have the permissions.",
+              :type => :error,
+              :buttons => :ok
+            )
+            result = false
+          end
+        end
+        result ||= true
+        return result
+      end
+
+      private
+
+      def get_path
+        @path || begin
+          if path = Application::Dialog.save_file(:filter_path => Manager.filter_path)
+            Manager.storage['last_dir'] = File.dirname(File.expand_path(path))
+            path
+          end
+        end
+      end
+    end
+
+    class DirectoryOpenCommand < Command
+
+      def initialize(path=nil)
+        @path = path
+      end
+
+      def execute
+        if path = get_path
+          project = Manager.open_project_for_path(path)
+          project.refresh if project
+        end
+      end
+
+      private
+
+      def get_path
+        @path || begin
+          if path = Application::Dialog.open_directory(:filter_path => Manager.filter_path)
+            Manager.storage['last_dir'] = File.dirname(File.expand_path(path))
+            path
+          end
+        end
+      end
+    end
+
+    class RefreshDirectoryCommand < ProjectCommand
+
+      def execute
+        project.refresh
+      end
+    end
+
+    class FindFileCommand < ProjectCommand
+
+      def execute
+        if Manager.focussed_project.remote?
+          Application::Dialog.message_box("Find file doesn't work in remote projects yet :(")
+          return
+        end
+        dialog = FindFileDialog.new(Manager.focussed_project)
+        dialog.open
+      end
+    end
+
+    class FindRecentCommand < Command
+      def execute
+        Redcar.app.make_sure_at_least_one_window_open
+        FindRecentDialog.new.open
+      end
+    end
+
+    class RevealInProjectCommand < ProjectCommand
+      def execute
+        if project
+          tab = Redcar.app.focussed_window.focussed_notebook_tab
+            if tab.is_a?(EditTab)
+            return unless mirror = tab.edit_view.document.mirror and mirror.respond_to? :path
+          else
+            return
+          end
+
+          path = mirror.path
+          tree = project.tree
+          current = tree.tree_mirror.top
+          while current.any?
+            ancestor_node = current.detect {|node| path =~ /^#{node.path}($|\/)/ }
+            return unless ancestor_node
+            tree.expand(ancestor_node)
+            current = ancestor_node.children
+          end
+          tree.select(ancestor_node)
+          project.window.treebook.focus_tree(project.tree)
+        end
+      end
+    end
+
+    class ToggleRevealInProject < ProjectCommand
+      def execute
+        toggle = Project::Manager.reveal_files?
+        Project::Manager.reveal_files = !toggle
+      end
+    end
+
+    # FIXME: XXX: The rest of this file is outright ugly. The Redcar.platform ultimately
+    # needs to return a platform object which we can dispatch to for commandlines,
+    # configuration, escaping and all that.
+    class OpenCommand < Command
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      def find(executable)
+        path = if Redcar.platform == :windows
+          ENV['PATH'].split(';')
+        else
+          ENV['PATH'].split(':')
+        end.find {|d| File.exist?(File.join(d, executable))}
+
+        if path
+          File.join(path, executable)
+        else
+          nil
+        end
+      end
+
+      def run_application(app, *options)
+        # TODO: Investigate why Spoon doesn't seem to work on osx
+        if SPOON_AVAILABLE and Redcar.platform != :osx
+          ::Spoon.spawn(app, *options)
+        else
+          # TODO: This really needs proper escaping.
+          options = options.map {|o| %{ "#{o}" } }.join(' ')
+          Thread.new do
+            system("#{app} #{options}")
+            puts "  Finished: #{app} #{options}"
+          end
+        end
+      end
+    end
+
+    class OpenDirectoryInExplorerCommand < OpenCommand
+      LinuxApps = {
+        'Thunar'    => '%s',
+        'nautilus'  => '%s',
+        'konqueror' => '%s',
+        'pcmanfm'   => '%s',
+        'kfm'       => '%s'
+      }
+
+      def explorer_osx
+        ['open -a Finder', path]
+      end
+
+      def explorer_windows
+        ['explorer.exe', path.gsub("/", "\\")]
+      end
+
+      def explorer_linux
+        preferred = Manager.storage['preferred_file_browser']
+        run = preferred if LinuxApps[preferred] and find(preferred)
+        LinuxApps.keys.detect {|a| run = @command.find(a) } unless run
+
+        Manager.storage['preferred_file_browser'] = run unless preferred
+
+        [run, LinuxApps[File.basename(run)] % path ] if run
+      end
+
+      def execute(options = nil)
+        @path ||= options[:value]
+        @command = self
+        cmd = send(:"explorer_#{Redcar.platform}")
+        if cmd
+          run_application(*cmd)
+        else
+          Application::Dialog.message_box("Sorry, we couldn't start your file manager. Please let us know what file manager you use, so we can fix this!")
+        end
+      end
+    end
+
+    class OpenDirectoryInCommandLineCommand < OpenCommand
+      LinuxApps = {
+        'xfce4-terminal' => "--working-directory=%s",
+        'gnome-terminal' => "--working-directory=%s",
+        'lxterminal'     => "--working-directory=%s",
+        'konsole'        => "--workdir %s"
+      }
+
+      def osx_terminal_script(preferred)
+        if preferred.start_with? "iTerm"
+          <<-OSASCRIPT
+            tell the first terminal
+              launch session "Default Session"
+                tell the last session
+                write text "cd \\\"#{path}\\\""
+              end tell
+            end tell
+          OSASCRIPT
+        else
+          %{ do script "cd \\\"#{path}\\\"" }
+        end
+      end
+
+      def commandline_osx
+        preferred = (Manager.storage['preferred_command_line'] ||= "Terminal")
+        <<-BASH.gsub(/^\s*/, '')
+          osascript <<END
+            tell application "#{preferred}"
+              #{osx_terminal_script(preferred)}
+              activate
+            end tell
+          END
+        BASH
+      end
+
+      def commandline_windows
+        ['start cmd.exe /kcd ', path.gsub("/","\\")]
+      end
+
+      def commandline_linux
+        preferred = Manager.storage['preferred_command_line']
+        run = preferred if LinuxApps[preferred] and find(preferred)
+        LinuxApps.keys.detect {|a| run = @command.find(a) } unless run
+
+        Manager.storage['preferred_command_line'] = run unless preferred
+
+        [run, LinuxApps[File.basename(run)] % path ] if run
+      end
+
+      def execute(options = nil)
+        @path ||= options[:value]
+        @command = self
+        cmd = send(:"commandline_#{Redcar.platform}")
+        if cmd
+          run_application(*cmd)
+        else
+          Application::Dialog.message_box("Sorry, we couldn't start your command line. Please let us know what command line you use, so we can fix this!")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,275 @@
+
+module Redcar
+  class Project
+    class DirController
+      include Redcar::Tree::Controller
+
+      def self.adapter(node, tree=nil)
+        node ? node.adapter : tree.tree_mirror.adapter
+      end
+
+      def activated(tree, node)
+        if node.leaf?
+          OpenFileCommand.new(node.path, node.adapter).run
+        end
+      end
+
+      def handle_error(tree, error)
+        tree.close
+        Application::Dialog.message_box(error.message, :type => :error)
+      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 and nodes.all? {|node| droppable?(node, target)}
+        end
+
+        def do_drop(nodes, target, position)
+          return unless nodes
+          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
+              adapter = DirController.adapter(target, tree)
+              adapter.mv(path, dir)
+            end
+          end
+          tree.refresh
+        end
+
+        private
+
+        def droppable?(from_node, target_node)
+          return false unless from_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.new
+        Redcar.plugin_manager.objects_implementing(:project_context_menus).each do |object|
+          # a lot of plugins will only really care about the node that was clicked
+          case object.method(:project_context_menus).arity
+          when 1
+            menu.merge(object.project_context_menus(node))
+          when 2
+            menu.merge(object.project_context_menus(tree, node))
+          when 3
+            menu.merge(object.project_context_menus(tree, node, controller))
+          else
+            puts("Invalid project_context_menus hook detected in "+object.class.name)
+          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)
+
+        adapter = DirController.adapter(node, tree)
+        adapter.touch(new_file_path)
+        tree.refresh
+        tree.expand(node)
+        new_file_node = DirMirror::Node.cache[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)
+        adapter = DirController.adapter(node, tree)
+        adapter.mkdir(new_dir_path)
+        tree.refresh
+        tree.expand(node)
+        new_dir_node = DirMirror::Node.cache[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
+        include Redcar::HtmlController
+
+        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 = ""
+          @adapter = DirController.adapter(nodes.first, tree)
+        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 = (@adapter.exists?(new_path) and new_name != old_name)
+            legal     = (new_name != "" and legal_path?(new_path))
+            [new_name, conflicts, legal]
+          end
+          result
+        rescue => e
+          puts e.class
+          puts e.message
+          puts e.backtrace
+        end
+
+        def 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)
+            @adapter.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|
+            node.adapter.delete(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
+
+        adapter = DirController.adapter(node, tree)
+        adapter.mv(node.path, new_path)
+        tree.refresh
+        new_node = DirMirror::Node.create_from_path(adapter, {:fullname => new_path, :type => node.type})
+        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
+
+