fargo 0.3.0 → 0.4.0

data/lib/fargo/cli/completion.rb

@@ -0,0 +1,41 @@
+require 'fargo/ext/readline'
+
+module Fargo
+  module CLI
+    module Completion
+
+      def setup_console
+        old_proc = Readline.completion_proc
+        Readline.basic_word_break_characters = " \t\n\\'"
+        Readline.basic_quote_characters = ''
+
+        Readline.completion_proc = lambda { |str|
+          input = Readline.get_input
+
+          candidates, data = [], nil
+          regex, proc = @completions.detect{ |k, _|
+            data = input.match(k)
+          }
+          if data
+            data = data.to_a
+            data.shift
+            candidates = proc.call *data
+          end
+
+          if candidates.empty?
+            old_proc.call str
+          else
+            str = str.gsub /^"/, ''
+            candidates.select{ |n| n.start_with? str }.map{ |s| s.inspect }
+          end
+        }
+      end
+
+      def add_completion regex, &block
+        @completions ||= {}
+        @completions[regex] = block
+      end
+
+    end
+  end
+end

data/lib/fargo/cli/downloads.rb

@@ -0,0 +1,57 @@
+module Fargo
+  module CLI
+    module Downloads
+
+      def setup_console
+        super
+
+        add_completion(/^(download|get)\s+\d+,\s*[^\s]*$/) do
+          client.searches
+        end
+
+        add_logger(:download_started) do |message|
+          "Download of #{message[:download][:file]} " +
+          "(#{humanize_bytes message[:length]}) " +
+          "from #{message[:nick]} started"
+        end
+
+        add_logger(:download_finished) do |message|
+          "Download of #{message[:download][:file]} " +
+          "finished into #{message[:file]}"
+        end
+      end
+
+      def download index, search = nil
+        search ||= client.searches[0]
+
+        if search.nil?
+          puts "Nothing to download!"
+          return
+        end
+
+        item = client.search_results(search)[index]
+
+        if item.nil?
+          puts 'That is not something to download!'
+        else
+          client.download item[:nick], item[:file], item[:tth], item[:size]
+        end
+      end
+
+      def transfers
+        max_nick = client.current_downloads.keys.map(&:size).max
+        client.current_downloads.each_pair do |nick, download|
+          printf "%#{max_nick}s %10s (%.2f%%) -- %s\n", nick,
+            humanize_bytes(download.size), 100 * download.percent,
+            download.file
+        end
+
+        puts "Upload slots avail: " +
+          "#{client.open_upload_slots}/#{client.config.upload_slots}  " +
+          "Download slots avail: " +
+          "#{client.open_download_slots}/#{client.config.download_slots}"
+      end
+
+    end
+  end
+end

data/lib/fargo/cli/help.rb

@@ -0,0 +1,80 @@
+module Fargo
+  module CLI
+    module Help
+
+      def setup_console
+        super
+
+        add_completion(/^man\s+[^\s]*$/){
+          ['man', 'results', 'search', 'ls', 'pwd', 'cwd', 'cd', 'browse',
+              'download', 'get', 'who', 'say', 'send_chat', 'transfers']
+        }
+      end
+
+      def man cmd = nil
+        cmd ||= 'man'
+
+        case cmd.to_sym
+          when :man
+            puts "Usage: man 'cmd'"
+          when :results
+            puts "Usage: results ['search string' | index], opts = {}"
+            puts ""
+            puts "  Show the results for a previous search. The search can be"
+            puts "  identified by its search string or its index of the search."
+            puts "  If no search string or index is given, the last search"
+            puts "  results are displayed if they exist."
+            puts ""
+            puts "  Recognized options:"
+            puts "    :full - if true, show full filenames instead of just base"
+            puts "    :sort - if 'size', sort results by size"
+            puts "    :grep - A regexp to filter results by"
+          when :search
+            puts "Usage: search ['string' | Search]"
+            puts ""
+            puts "  Search the hub for something. Either a string or a Search"
+            puts "  object can be specified."
+          when :ls
+            puts "Usage: ls ['dir']"
+            puts ""
+            puts "  Lists a directory. If no directory is given, lists the"
+            puts "  current one."
+          when :pwd, :cwd
+            puts "Usage: pwd/cwd"
+            puts ""
+            puts "  Show your current directory when browsing a user"
+          when :cd
+            puts "Usage: cd ['dir']"
+            puts ""
+            puts "  Works just like on UNIX. No argument means go to root"
+          when :browse
+            puts "Usage: browse 'nick'"
+            puts ""
+            puts "  Begin browisng a nick. If no file list has been downloaded,"
+            puts "  one is queued for download and you will be notified when"
+            puts "  browsing is ready."
+          when :download, :get
+            puts "Usage: "
+          when :who
+            puts "Usage: who ['nick' | 'size' | 'name']"
+            puts ""
+            puts "  If no argument is given, shows all users on the hub. If a"
+            puts "  name is given, shows that user on the hub. If 'size' or"
+            puts "  'name' is given, the users are sorted by that attribute."
+          when :say, :send_chat
+            puts "Usage: say/send_chat 'msg'"
+            puts ""
+            puts "  Send a message to the hub"
+          when :transfers
+            puts "Usage: transfers"
+            puts ""
+            puts "  Show some statistics about transfers happening."
+          else
+            puts "Unknown commnand: #{cmd}"
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fargo/cli/info.rb

@@ -0,0 +1,55 @@
+require 'active_support/core_ext/module/delegation'
+
+module Fargo
+  module CLI
+    module Info
+
+      delegate :send_chat, :to => :client
+      alias :say :send_chat
+
+      def setup_console
+        super
+
+        add_completion(/^who\s+[^\s]*$/) { client.nicks + ['size', 'name'] }
+      end
+
+      def who sort_by = nil
+        print_nick = lambda{ |p|
+          printf "%10s %s\n", humanize_bytes(p[1]), p[0]
+        }
+
+        if client.nicks.include? sort_by
+          info = client.info(sort_by)
+          key_len = info.keys.map{ |k| k.to_s.length }.max
+
+          info.each_pair do |k, v|
+            next if k == :type
+            printf "%#{key_len}s: %s\n", k,
+              v.is_a?(Numeric) ? humanize_bytes(v) : v
+          end
+        elsif sort_by.nil?
+          client.nicks.each do |n|
+            print_nick.call [n, client.info(n)[:sharesize]]
+          end
+        else
+          pairs = client.nicks.map{ |n|
+            [n, client.info(n)[:sharesize]]
+          }
+
+          if sort_by == 'name'
+            pairs = pairs.sort_by{ |p| p[0] }
+          elsif sort_by == 'size'
+            pairs = pairs.sort_by{ |p| p[1] }
+          else
+            pairs = []
+            puts "Unknown sorting by: #{sort_by.inspect}"
+          end
+          pairs.each &print_nick
+        end
+
+        true
+      end
+
+    end
+  end
+end

data/lib/fargo/cli/logging.rb

@@ -0,0 +1,87 @@
+require 'drb'
+require 'em-http-request'
+
+module Fargo
+  module CLI
+    module Logging
+
+      attr_writer :client
+
+      def setup_console
+        super
+
+        add_logger(:chat) do |message|
+          "<#{message[:from]}>: #{message[:text]}"
+        end
+
+        add_logger(:hub_disconnected) do |_|
+          puts "Hub disconnected, exiting..."
+          exit
+        end
+      end
+
+      def add_logger type, &block
+        @logging[type.to_s] << block
+      end
+
+      def client
+        @client ||= DRbObject.new_with_uri 'druby://127.0.0.1:8082'
+      end
+
+      def log_published_messages
+        @logging = Hash.new{ |h, k| h[k] = [] }
+
+        streamer = proc {
+          host = "ws://#{client.config.websocket_host}" +
+                    ":#{client.config.websocket_port}/"
+
+          ws = EventMachine::HttpRequest.new(host).get(:timeout => 0)
+
+          ws.disconnect {
+            Readline.above_prompt{ puts "Stopping logging stream." }
+          }
+
+          ws.callback {
+            Readline.above_prompt{ puts "Streaming logging messages." }
+          }
+
+          ws.stream { |msg|
+            to_log = nil
+            type, message = Marshal.load(Base64.decode64(msg))
+
+            @logging[type.to_s].each{ |l|
+              to_log = l.call message
+              Readline.above_prompt{ puts to_log } unless to_log.nil?
+            }
+          }
+        }
+
+        if EventMachine.reactor_running?
+          EventMachine.schedule streamer
+        else
+          Thread.start{ EventMachine.run streamer }
+        end
+      end
+
+      protected
+
+      def humanize_bytes bytes
+        suffix = 'B'
+        while bytes > 1024
+          suffix = case suffix
+            when 'B' then 'K'
+            when 'K' then 'M'
+            when 'M' then 'G'
+            when 'G' then 'T'
+            when 'T' then break
+          end
+
+          bytes /= 1024.0
+        end
+
+        '%.2f %s' % [bytes, suffix]
+      end
+
+    end
+  end
+end

data/lib/fargo/cli/nick_browser.rb

@@ -0,0 +1,159 @@
+require 'pathname'
+
+module Fargo
+  module CLI
+    module NickBrowser
+      extend ActiveSupport::Concern
+
+      included do
+        alias :get :download
+      end
+
+      module InstanceMethods
+        def setup_console
+          super
+
+          @fixed_completions = {}
+
+          add_completion(/^browse\s+[^\s]*$/) { client.nicks }
+
+          file_regex = /(?:\s+(?:[^\s,]*))+/
+          add_completion(/^(?:get|download)#{file_regex}$/) { completion true }
+          add_completion(/^(?:ls|cd)#{file_regex}$/) { completion }
+
+          add_logger(:download_finished) do |message|
+            if message[:file].end_with? 'files.xml.bz2'
+              begin_browsing message[:nick]
+            end
+          end
+        end
+
+        def download file, other = nil
+          if file.is_a?(String)
+            resolved = resolve(file).to_s
+            listing = drilldown resolved, @file_list
+
+            if listing.nil?
+              puts "No file to download!: #{file}"
+            elsif listing.is_a? Hash
+              # Recursively download the entire directory
+              listing.keys.each do |k|
+                download File.join(resolved, k)
+              end
+            else
+              client.download listing
+            end
+          else
+            super
+          end
+        end
+      end
+
+      def browse nick
+        @browsing  = nick
+        @file_list = nil
+        list       = client.file_list nick
+        begin_browsing nick, false if list.is_a?(Hash)
+      end
+
+      def cd dir = '/'
+        cwd = resolve(dir)
+        if drilldown(cwd, @file_list).nil?
+          puts "#{dir.inspect} doesn't exist!"
+        else
+          @cwd = cwd
+          pwd
+        end
+      end
+
+      def pwd
+        puts @cwd.to_s
+      end
+
+      alias :cwd :pwd
+
+      def ls dir = ''
+        if @cwd.nil? || @file_list.nil?
+          puts "Note browsing any nick!"
+          return
+        end
+
+        hash = drilldown(resolve(dir), @file_list)
+
+        hash.keys.sort_by(&:downcase).
+            sort_by{ |k| hash[k].is_a?(Hash) ? 0 : 1 }.each do |key|
+          if hash[key].is_a?(Hash)
+            puts "#{key}/"
+          else
+            printf "%10s -- %s\n", humanize_bytes(hash[key].size), key
+          end
+        end
+
+        true
+      end
+
+      def begin_browsing nick, above_prompt = true
+        @cwd = Pathname.new '/'
+        @file_list = client.file_list(@browsing)
+
+        if above_prompt
+          Readline.above_prompt{ puts "#{@browsing} ready for browsing" }
+        else
+          puts "#{@browsing} ready for browsing"
+        end
+      end
+
+      protected
+
+      def completion include_files = false
+        if @browsing
+          all_input = Readline.get_input
+          dirs = []
+          while tmp = all_input.slice!(/[^\s]+?\s+/)
+            dirs << tmp.rstrip.gsub!(/"/, '')
+          end
+          dirs.shift # original command
+
+          resolved = resolve dirs.join('/'), false
+          hash     = drilldown resolved, @file_list
+
+          keys = hash.keys rescue []
+          keys = keys.select{ |k|
+            include_files || k == '..' || hash[k].is_a?(Hash)
+          }
+          keys << '..' unless keys.empty? && dirs.size != 0
+
+          keys.map{ |k|
+            suffix = hash[k].is_a?(Hash) ? '/' : ''
+
+            # Readline doesn't like completing words with spaces in the file
+            # name, so just display them as periods when in actuality we'll
+            # convert back to a space later
+            (k.gsub(' ', '.') + suffix).tap do |str|
+              key = @cwd.join(*dirs).join(str).expand_path.to_s
+              @fixed_completions[key] = resolved.join k
+            end
+          }
+        else
+          []
+        end
+      end
+
+      def resolve dir, clear_cache = true
+        return '' if @cwd.nil?
+
+        res = @fixed_completions[@cwd.join(dir).expand_path.to_s] ||
+                @cwd.join(dir).expand_path
+        @fixed_completions.clear if clear_cache
+        res.expand_path
+      end
+
+      def drilldown path, list
+        path.to_s.gsub(/^\//, '').split('/').inject(list) { |hash, part|
+          hash ? hash[part] : nil
+        }
+      end
+
+    end
+  end
+end