redcar 0.12.1 → 0.13

data/plugins/outline_view_swt/plugin.rb

@@ -1,7 +0,0 @@
-Plugin.define do
-  name    "outline_view_swt"
-  version "0.1.0"
-  file    "lib", "outline_view_swt"
-  object  "Redcar::OutlineViewSWT"
-  dependencies "application_swt", ">0"
-end

data/plugins/project/lib/project/adapters/remote.rb

@@ -1,96 +0,0 @@
-
-module Redcar
-  class Project
-    module Adapters
-      class Remote
-        class PathDoesNotExist < StandardError; end
-
-        PROTOCOLS = {
-          :ftp  => RemoteProtocols::FTP,
-          :sftp => RemoteProtocols::SFTP
-        }
-
-        attr_accessor :protocol, :host, :user, :password, :private_key_files
-
-        def initialize(protocol, host, user, password, private_key_files)
-          @protocol = protocol
-          @host = host
-          @user = user
-          @password = password
-          @private_key_files = private_key_files
-          target
-        end
-
-        def target
-          @target ||= PROTOCOLS[protocol].new(host, user, password, private_key_files)
-        end
-
-        def touch(file)
-          target.touch(file)
-        end
-
-        def mkdir(new_dir_path)
-          target.mkdir(new_dir_path)
-        end
-
-        def mv(path, new_path)
-          target.mv(path, new_path)
-          Manager.update_tab_for_path(path,new_path)
-        end
-
-        def mtime(file)
-          target.mtime(file)
-        end
-
-        def file?(path)
-          target.file?(path)
-        end
-
-        def directory?(path)
-          target.directory?(path)
-        end
-
-        def fetch_contents(path)
-          target.fetch_contents(path)
-        end
-
-        def load(file)
-          target.load(file)
-        end
-
-        def save(file, contents)
-          target.save(file)
-        end
-
-        def stat(file)
-          target.stat(file)
-        end
-
-        def delete(file)
-          target.delete(file)
-          Manager.update_tab_for_path(file)
-        end
-
-        def exists?(path)
-          target.exists?(path)
-        end
-
-        def load(file)
-          target.load(file)
-        end
-
-        def save(file, contents)
-          target.save(file, contents)
-        end
-
-        def refresh_operation(tree)
-          visible_paths = tree.visible_nodes.map {|n| n.path}
-          visible_dirs = visible_paths.map {|path| File.dirname(path) }.uniq
-          target.with_cached_directories(visible_dirs) do
-            yield
-          end
-        end
-      end
-    end
-  end
-end

data/plugins/project/lib/project/adapters/remote_protocols/ftp.rb

@@ -1,93 +0,0 @@
-
-module Redcar
-  class Project
-    module Adapters
-      module RemoteProtocols
-        class FTP < Protocol
-          class << self
-            def handle_error(e, host, user)
-              return "Authentication failed for user #{user} in ftp://#{host}" if e.is_a?(Net::FTPPermError)
-            end
-          end
-          
-          def connection
-            require 'net/ftp'
-            gem "net-ftp-list"
-            require 'net/ftp/list'
-            @connection ||= Net::FTP.open(host, user, password)
-          end
-          
-          def touch(file)
-            local_path, local_file = split_paths(file)
-
-            FileUtils.mkdir_p local_path
-            FileUtils.touch local_file
-
-            upload local_file, file
-          end
-
-          def mkdir(new_dir_path)
-            exec :mkdir, new_dir_path
-          end
-
-          def mv(path, new_path)
-            target = "#{new_path}/#{File.basename(path)}"
-            exec :rename, path, target
-          end
-          
-          def mtime(file)
-            if e = entry(file)
-              e[:mtime]
-            end
-          end
-          
-          def download(remote, local)
-            exec :get, remote, local
-          end
-          
-          def upload(local, remote)
-            exec :put, local, remote
-          end
-
-          def dir_listing(path)
-            contents = []
-            exec(:list, path) do |e|
-              entry = Net::FTP::List.parse(e)
-              name = entry.basename
-              type = "unknown"
-              type = "file" if entry.file?
-              type = "dir" if entry.dir?
-              
-              unless ['.', '..'].include?(name)
-                contents << { :fullname => "#{path}/#{name}", :name => "#{name}", :type => type, :mtime => entry.mtime }
-              end
-            end
-            
-            contents
-          end
-          
-          def is_folder(path)
-            exec(:chdir, path)
-            exec(:pwd) == path
-          end
-          
-          def with_cached_directories
-            yield
-          end
-          
-          private
-          
-          def exec(method, *args, &block)
-            begin
-              Redcar.timeout(10) do
-                connection.send(method, *args, &block)
-              end
-            rescue Redcar::TimeoutError
-              raise "#{host} connection timed out"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/plugins/project/lib/project/adapters/remote_protocols/protocol.rb

@@ -1,94 +0,0 @@
-
-module Redcar
-  class Project
-    module Adapters
-      module RemoteProtocols
-        class Protocol
-          attr_accessor :host, :user, :password, :private_key_files
-          
-          def initialize(host, user, password, private_key_files)
-            @host     = host
-            @user     = user
-            @password = password
-            @cache    = {}
-            @private_key_files = private_key_files
-            connection
-          end
-          
-          def exists?(path)
-            !!entry(path)
-          end
-          
-          def directory?(path)
-            return false unless entry = entry(path)
-            entry[:type] == :dir
-          end
-          
-          def file?(path)
-            return false unless entry = entry(path)
-            entry[:type] == :file
-          end
-          
-          def fetch_contents(path)
-            fetch(path)
-          end
-          
-          def load(file)
-            local_path, local_file = split_paths(file)
-
-            FileUtils.mkdir_p local_path
-            download file, local_file
-            File.open(local_file, 'rb') do |f|; f.read; end
-          end
-          
-          def save(file, contents)
-            local_path, local_file = split_paths(file)
-
-            ret = File.open(local_file, "wb") {|f| f.print contents }
-            upload local_file, file
-            
-            ret
-          end
-
-          private
-          
-          def cache(path)
-            @cache[path]
-          end
-
-          def check_folder(path)
-            parent = File.dirname(path)
-            if contents = cache(parent)
-              result = contents.find { |f| f[:fullname] == path }
-              return false unless result
-              result[:type] == :dir
-            else
-              is_folder(path)
-            end
-          end
-          
-          def split_paths(file)
-            base_temp = '/tmp'
-            file_name = File.basename(file)
-            path = File.dirname(file)
-
-            local_path = "#{base_temp}/#{host}#{path}"
-            local_file = "#{local_path}/#{file_name}"
-
-            [local_path, local_file]
-          end
-
-          def entry(file)
-            path = File.dirname(file)
-            contents = fetch(path)
-            contents.detect { |f| f[:fullname] == file }
-          end
-
-          def fetch(path)
-            dir_listing(path)
-          end
-        end
-      end
-    end
-  end
-end

data/plugins/project/lib/project/adapters/remote_protocols/sftp.rb

@@ -1,181 +0,0 @@
-
-module Redcar
-  class Project
-    module Adapters
-      module RemoteProtocols
-        class SFTP < Protocol
-          class << self
-            def handle_error(e, host, user)
-              return "Authentication failed for user #{user} in sftp://#{host}" if e.is_a?(Net::SSH::AuthenticationFailed)
-            end
-          end
-
-          def connection
-            gem "net-ssh"
-            gem "net-sftp"
-            require 'net/ssh'
-            require 'net/sftp'
-            Redcar.timeout(10) do
-              @connection ||= Net::SSH.start(host, user, :password => password, :keys => private_key_files)
-            end
-          rescue OpenSSL::PKey::DSAError => error
-            puts "*** Warning, DSA keys not supported."
-            # Error with DSA key. Throw us back to a password input. Think this is because jopenssl bugs
-            # out on valid dsa keys.
-            raise Net::SSH::AuthenticationFailed, "DSA key-based authentication failed."
-          rescue Redcar::TimeoutError
-            raise "connection to #{host} timed out"
-          end
-          
-          def touch(file)
-            exec "touch \"#{escape(file)}\""
-          end
-
-          def mkdir(new_dir_path)
-            exec "mkdir -p \"#{escape(new_dir_path)}\""
-          end
-
-          def mv(path, new_path)
-            exec "mv \"#{escape(path)}\" \"#{escape(new_path)}\""
-          end
-          
-          def mtime(file)
-            sftp_exec(:stat!, file).mtime
-          end
-          
-          def download(remote, local)
-            sftp_exec(:download!, remote, local)
-          end
-          
-          def upload(local, remote)
-            sftp_exec(:upload!, local, remote)
-          end
-          
-          def delete(file)
-            sftp_exec(:remove, file)
-          end
-          
-          def use_cache?
-            @use_cache
-          end
-          
-          def dir_listing(path)
-            if use_cache?
-              if @cached_dirs[path]
-                return @cached_dirs[path]
-              end
-            end
-            
-            return [] unless result = retrieve_dir_listing(path)
-            process_dir_listing_response(result)
-          end
-          
-          def retrieve_dir_listing(path)
-            raise Adapters::Remote::PathDoesNotExist, "Path #{path} does not exist" unless check_folder(path)
-
-            exec %Q(
-              for file in #{path}/*; do 
-                test -f "$file" && echo "file|na|$file"
-                test -d "$file" && test $(find $file -maxdepth 1 | wc -l) -eq 1 && echo "dir|0|$file"
-                test -d "$file" && test $(find $file -maxdepth 1 | wc -l) -gt 1 && echo "dir|1|$file"
-              done
-            )
-          end
-          
-          def process_dir_listing_response(response)
-            contents = []
-            response.each do |line|
-              next unless line.include?('|')
-              type, empty_flag, name = line.chomp.split('|')
-              unless ['.', '..'].include?(name)
-                hash = { :fullname => name, :name => File.basename(name), :type => type.to_sym }
-                if type == "dir"
-                  hash[:empty] = (empty_flag == "0")
-                end
-                contents << hash
-              end
-            end
-            contents
-          end
-          
-          def exists?(path)
-            is_file(path) or is_folder(path)
-          end
-          
-          def is_folder(path)
-            result = exec(%Q(
-              test -d "#{path}" && echo y
-            )) 
-
-            result =~ /^y/ ? true : false
-          end
-          
-          def is_file(path)
-            result = exec(%Q(
-              test -f "#{path}" && echo y
-            )) 
-
-            result =~ /^y/ ? true : false
-          end
-          
-          def with_cached_directories(dirs)
-            @cached_dirs = list_dirs(dirs)
-            @use_cache = true
-            yield
-          ensure
-            @use_cache = false
-          end
-          
-          def list_dirs(dirs)
-            cmd = ""
-            dirs.each do |dir|
-              cmd << <<-SH
-                for file in #{dir}/*; do 
-                  test -f "$file" && echo "file|na|$file"
-                  test -d "$file" && test $(find "$file" -maxdepth 1 | wc -l) -eq 1 && echo "dir|0|$file"
-                  test -d "$file" && test $(find "$file" -maxdepth 1 | wc -l) -gt 1 && echo "dir|1|$file"
-                done
-              SH
-            end
-            response = exec(cmd)
-            listings = process_dir_listing_response(response)
-            hash = {}
-            listings.each do |listing|
-              (hash[File.dirname(listing[:fullname])] ||= []) << listing
-            end
-            hash
-          end
-          
-          private
-          
-          def escape(path)
-            path.gsub("\\", "\\\\").gsub("\"", "\\\"")
-          end
-          
-          def exec(what)
-            puts "exec: #{what.inspect}"
-            begin
-              Redcar.timeout(10) do
-                connection.exec!(what)
-              end
-            rescue Redcar::TimeoutError => e
-              connection.shutdown!
-              raise "#{host} connection timed out"
-            end
-          end
-          
-          def sftp_exec(method, *args)
-            begin
-              Redcar.timeout(10) do
-                connection.sftp.send(method, *args)
-              end
-            rescue Redcar::TimeoutError
-              connection.shutdown!
-              raise "#{host} connection timed out"
-            end
-          end
-        end
-      end
-    end
-  end
-end