sup 0.19.0

data/lib/sup/modes/buffer_list_mode.rb

@@ -0,0 +1,50 @@
+module Redwood
+
+class BufferListMode < LineCursorMode
+  register_keymap do |k|
+    k.add :jump_to_buffer, "Jump to selected buffer", :enter
+    k.add :reload, "Reload buffer list", "@"
+    k.add :kill_selected_buffer, "Kill selected buffer", "X"
+  end
+
+  def initialize
+    regen_text
+    super
+  end
+
+  def lines; @text.length end
+  def [] i; @text[i] end
+
+  def focus
+    reload # buffers may have been killed or created since last view
+    set_cursor_pos 0
+  end
+
+protected
+
+  def reload
+    regen_text
+    buffer.mark_dirty
+  end
+
+  def regen_text
+    @bufs = BufferManager.buffers.reject { |name, buf| buf.mode == self || buf.hidden? }.sort_by { |name, buf| buf.atime }.reverse
+    width = @bufs.max_of { |name, buf| buf.mode.name.length }
+    @text = @bufs.map do |name, buf|
+      base_color = buf.system? ? :system_buf_color : :regular_buf_color
+      [[base_color, sprintf("%#{width}s ", buf.mode.name)],
+       [:modified_buffer_color, (buf.mode.unsaved? ? '*' : ' ')],
+       [base_color, " " + name]]
+    end
+  end
+
+  def jump_to_buffer
+    BufferManager.raise_to_front @bufs[curpos][1]
+  end
+
+  def kill_selected_buffer
+    reload if BufferManager.kill_buffer_safely @bufs[curpos][1]
+  end
+end
+
+end

data/lib/sup/modes/completion_mode.rb

@@ -0,0 +1,55 @@
+module Redwood
+
+class CompletionMode < ScrollMode
+  INTERSTITIAL = "  "
+
+  def initialize list, opts={}
+    @list = list
+    @header = opts[:header]
+    @prefix_len = opts[:prefix_len]
+    @lines = nil
+    super :slip_rows => 1, :twiddles => false
+  end
+
+  def lines
+    update_lines unless @lines
+    @lines.length
+  end
+
+  def [] i
+    update_lines unless @lines
+    @lines[i]
+  end
+
+  def roll; if at_bottom? then jump_to_start else page_down end end
+
+private
+
+  def update_lines
+    width = buffer.content_width
+    max_length = @list.max_of { |s| s.length }
+    num_per = [1, buffer.content_width / (max_length + INTERSTITIAL.length)].max
+    @lines = [@header].compact
+    @list.each_with_index do |s, i|
+      if @prefix_len
+        @lines << [] if i % num_per == 0
+        if @prefix_len < s.length
+          prefix = s[0 ... @prefix_len]
+          suffix = s[(@prefix_len + 1) .. -1]
+          char = s[@prefix_len].chr
+
+          @lines.last += [[:text_color, sprintf("%#{max_length - suffix.length - 1}s", prefix)],
+                          [:completion_character_color, char],
+                          [:text_color, suffix + INTERSTITIAL]]
+        else
+          @lines.last += [[:text_color, sprintf("%#{max_length}s#{INTERSTITIAL}", s)]]
+        end
+      else
+        @lines << "" if i % num_per == 0
+        @lines.last += sprintf "%#{max_length}s#{INTERSTITIAL}", s
+      end
+    end
+  end
+end
+
+end

data/lib/sup/modes/compose_mode.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module Redwood
+
+class ComposeMode < EditMessageMode
+  def initialize opts={}
+    header = {}
+    header["From"] = (opts[:from] || AccountManager.default_account).full_address
+    header["To"] = opts[:to].map { |p| p.full_address }.join(", ") if opts[:to]
+    header["Cc"] = opts[:cc].map { |p| p.full_address }.join(", ") if opts[:cc]
+    header["Bcc"] = opts[:bcc].map { |p| p.full_address }.join(", ") if opts[:bcc]
+    header["Subject"] = opts[:subj] if opts[:subj]
+    header["References"] = opts[:refs].map { |r| "<#{r}>" }.join(" ") if opts[:refs]
+    header["In-Reply-To"] = opts[:replytos].map { |r| "<#{r}>" }.join(" ") if opts[:replytos]
+
+    super :header => header, :body => (opts[:body] || [])
+  end
+
+  def default_edit_message
+    edited = super
+    BufferManager.kill_buffer self.buffer unless edited
+    edited
+  end
+
+  def self.spawn_nicely opts={}
+    from = opts[:from] || (BufferManager.ask_for_account(:account, "From (default #{AccountManager.default_account.email}): ") or return if $config[:ask_for_from])
+    to = opts[:to] || (BufferManager.ask_for_contacts(:people, "To: ", [opts[:to_default]]) or return if ($config[:ask_for_to] != false))
+    cc = opts[:cc] || (BufferManager.ask_for_contacts(:people, "Cc: ") or return if $config[:ask_for_cc])
+    bcc = opts[:bcc] || (BufferManager.ask_for_contacts(:people, "Bcc: ") or return if $config[:ask_for_bcc])
+    subj = opts[:subj] || (BufferManager.ask(:subject, "Subject: ") or return if $config[:ask_for_subject])
+
+    mode = ComposeMode.new :from => from, :to => to, :cc => cc, :bcc => bcc, :subj => subj
+    BufferManager.spawn "New Message", mode
+    mode.default_edit_message
+  end
+end
+
+end

data/lib/sup/modes/console_mode.rb

@@ -0,0 +1,125 @@
+require 'pp'
+
+require "sup/service/label_service"
+
+module Redwood
+
+class Console
+  def initialize mode
+    @mode = mode
+    @label_service = LabelService.new
+  end
+
+  def query(query)
+    Enumerator.new(Index.instance, :each_message, Index.parse_query(query))
+  end
+
+  def add_labels(query, *labels)
+    count = @label_service.add_labels(query, *labels)
+    print_buffer_dirty_msg count
+  end
+
+  def remove_labels(query, *labels)
+    count = @label_service.remove_labels(query, *labels)
+    print_buffer_dirty_msg count
+  end
+
+  def print_buffer_dirty_msg msg_count
+    puts "Scanned #{msg_count} messages."
+    puts "You might want to refresh open buffers with `@` key."
+  end
+  private :print_buffer_dirty_msg
+
+  def xapian; Index.instance.instance_variable_get :@xapian; end
+
+  def loglevel; Redwood::Logger.level; end
+  def set_loglevel(level); Redwood::Logger.level = level; end
+
+  def special_methods; public_methods - Object.methods end
+
+  def puts x; @mode << "#{x.to_s.rstrip}\n" end
+  def p x; puts x.inspect end
+
+  ## files that won't cause problems when reloaded
+  ## TODO expand this list / convert to blacklist
+  RELOAD_WHITELIST = %w(sup/index.rb sup/modes/console-mode.rb)
+
+  def reload
+    old_verbose = $VERBOSE
+    $VERBOSE = nil
+    old_features = $".dup
+    begin
+      fs = $".grep(/^sup\//)
+      fs.reject! { |f| not RELOAD_WHITELIST.member? f }
+      fs.each { |f| $".delete f }
+      fs.each do |f|
+        @mode << "reloading #{f}\n"
+        begin
+          require f
+        rescue LoadError => e
+          raise unless e.message =~ /no such file to load/
+        end
+      end
+    rescue Exception
+      $".clear
+      $".concat old_features
+      raise
+    ensure
+      $VERBOSE = old_verbose
+    end
+    true
+  end
+
+  def clear_hooks
+    HookManager.clear
+    nil
+  end
+end
+
+class ConsoleMode < LogMode
+  register_keymap do |k|
+    k.add :run, "Restart evaluation", 'e'
+  end
+
+  def initialize
+    super "console"
+    @console = Console.new self
+    @binding = @console.instance_eval { binding }
+  end
+
+  def execute cmd
+    begin
+      self << ">> #{cmd}\n"
+      ret = eval cmd, @binding
+      self << "=> #{ret.pretty_inspect}\n"
+    rescue Exception
+      self << "#{$!.class}: #{$!.message}\n"
+      clean_backtrace = []
+      $!.backtrace.each { |l| break if l =~ /console-mode/; clean_backtrace << l }
+      clean_backtrace.each { |l| self << "#{l}\n" }
+    end
+  end
+
+  def prompt
+    BufferManager.ask :console, ">> "
+  end
+
+  def run
+    self << <<EOS
+Sup v#{VERSION} console session started.
+Available extra commands: #{(@console.special_methods) * ", "}
+Ctrl-G stops evaluation; 'e' restarts it.
+
+EOS
+    while true
+      if(cmd = prompt)
+        execute cmd
+      else
+        self << "Console session ended."
+        break
+      end
+    end
+  end
+end
+
+end

data/lib/sup/modes/contact_list_mode.rb

@@ -0,0 +1,148 @@
+module Redwood
+
+module CanAliasContacts
+  def alias_contact p
+    aalias = BufferManager.ask(:alias, "Alias for #{p.longname}: ", ContactManager.alias_for(p))
+    return if aalias.nil?
+    aalias = nil if aalias.empty? # allow empty aliases
+
+    name = BufferManager.ask(:name, "Name for #{p.longname}: ", p.name)
+    return if name.nil? || name.empty? # don't allow empty names
+    p.name = name
+
+    ContactManager.update_alias p, aalias
+    BufferManager.flash "Contact updated!"
+  end
+end
+
+class ContactListMode < LineCursorMode
+  LOAD_MORE_CONTACTS_NUM = 100
+
+  register_keymap do |k|
+    k.add :load_more, "Load #{LOAD_MORE_CONTACTS_NUM} more contacts", 'M'
+    k.add :reload, "Drop contact list and reload", 'D'
+    k.add :alias, "Edit alias/or name for contact", 'a', 'i'
+    k.add :toggle_tagged, "Tag/untag current line", 't'
+    k.add :apply_to_tagged, "Apply next command to all tagged items", '+'
+    k.add :search, "Search for messages from particular people", 'S'
+  end
+
+  def initialize mode=:regular
+    @mode = mode
+    @tags = Tagger.new self, "contact"
+    @num = nil
+    @text = []
+    super()
+  end
+
+  include CanAliasContacts
+  def alias
+    p = @contacts[curpos] or return
+    alias_contact p
+    update
+  end
+
+  def lines; @text.length; end
+  def [] i; @text[i]; end
+
+  def toggle_tagged
+    p = @contacts[curpos] or return
+    @tags.toggle_tag_for p
+    update_text_for_line curpos
+    cursor_down
+  end
+
+  def multi_toggle_tagged threads
+    @tags.drop_all_tags
+    update
+  end
+
+  def apply_to_tagged; @tags.apply_to_tagged; end
+
+  def load_more num=LOAD_MORE_CONTACTS_NUM
+    @num += num
+    load
+    update
+    BufferManager.flash "Added #{num.pluralize 'contact'}."
+  end
+
+  def multi_select people
+    case @mode
+    when :regular
+      mode = ComposeMode.new :to => people
+      BufferManager.spawn "new message", mode
+      mode.default_edit_message
+    end
+  end
+
+  def select
+    p = @contacts[curpos] or return
+    multi_select [p]
+  end
+
+  def multi_search people
+    mode = PersonSearchResultsMode.new people
+    BufferManager.spawn "search for #{people.map { |p| p.name }.join(', ')}", mode
+    mode.load_threads :num => mode.buffer.content_height
+  end
+
+  def search
+    p = @contacts[curpos] or return
+    multi_search [p]
+  end
+
+  def reload
+    @tags.drop_all_tags
+    @num = nil
+    load
+  end
+
+  def load_in_background
+    Redwood::reporting_thread("contact manager load in bg") do
+      load
+      update
+      BufferManager.draw_screen
+    end
+  end
+
+  def load
+    @num ||= (buffer.content_height * 2)
+    @user_contacts = ContactManager.contacts_with_aliases
+    num = [@num - @user_contacts.length, 0].max
+    BufferManager.say("Loading #{num} contacts from index...") do
+      recentc = Index.load_contacts AccountManager.user_emails, :num => num
+      @contacts = (@user_contacts + recentc).sort_by { |p| p.sort_by_me }.uniq
+    end
+  end
+
+protected
+
+  def update
+    regen_text
+    buffer.mark_dirty if buffer
+  end
+
+  def update_text_for_line line
+    @text[line] = text_for_contact @contacts[line]
+    buffer.mark_dirty if buffer
+  end
+
+  def text_for_contact p
+    aalias = ContactManager.alias_for(p) || ""
+    [[:tagged_color, @tags.tagged?(p) ? ">" : " "],
+     [:text_color, sprintf("%-#{@awidth}s %-#{@nwidth}s %s", aalias, p.name, p.email)]]
+  end
+
+  def regen_text
+    @awidth, @nwidth = 0, 0
+    @contacts.each do |p|
+      aalias = ContactManager.alias_for(p)
+      @awidth = aalias.length if aalias && aalias.length > @awidth
+      @nwidth = p.name.length if p.name && p.name.length > @nwidth
+    end
+
+    @text = @contacts.map { |p| text_for_contact p }
+  end
+end
+
+end

data/lib/sup/modes/edit_message_async_mode.rb

@@ -0,0 +1,110 @@
+module Redwood
+
+class EditMessageAsyncMode < LineCursorMode
+
+  HookManager.register "async-edit", <<EOS
+Runs when 'H' is pressed in async edit mode. You can run whatever code
+you want here - though the default case would be launching a text
+editor. Your hook is assumed to not block, so you should use exec() or
+fork() to launch the editor.
+
+Once the hook has returned then sup will be responsive as usual. You will
+still need to press 'E' to exit this buffer and send the message.
+
+Variables:
+file_path: The full path to the file containing the message to be edited.
+
+Return value: None
+EOS
+
+  register_keymap do |k|
+    k.add :run_async_hook, "Run the async-edit hook", 'H'
+    k.add :edit_finished, "Finished editing message", 'E'
+    k.add :path_to_clipboard, "Copy file path to the clipboard", :enter
+  end
+
+  def initialize parent_edit_mode, file_path, msg_subject
+    @parent_edit_mode = parent_edit_mode
+    @file_path = file_path
+    @orig_mtime = File.mtime @file_path
+
+    @text = ["ASYNC MESSAGE EDIT",
+             "", "Your message with subject:",  msg_subject, "is saved in a file:", "", @file_path, "",
+             "You can edit your message in the editor of your choice and continue to",
+             "use sup while you edit your message.", "",
+             "Press <Enter> to have the file path copied to the clipboard.", "",
+             "When you have finished editing, select this buffer and press 'E'.",]
+    run_async_hook()
+    super()
+  end
+
+  def lines; @text.length end
+
+  def [] i
+    @text[i]
+  end
+
+  def killable?
+    if file_being_edited?
+      if !BufferManager.ask_yes_or_no("It appears the file is still being edited. Are you sure?")
+        return false
+      end
+    end
+
+    @parent_edit_mode.edit_message_async_resume true
+    true
+  end
+
+  def unsaved?
+    !file_being_edited? && !file_has_been_edited?
+  end
+
+protected
+
+  def edit_finished
+    if file_being_edited?
+      if !BufferManager.ask_yes_or_no("It appears the file is still being edited. Are you sure?")
+        return false
+      end
+    end
+
+    @parent_edit_mode.edit_message_async_resume
+    BufferManager.kill_buffer buffer
+    true
+  end
+
+  def path_to_clipboard
+    if system("which xsel > /dev/null 2>&1")
+      # linux/unix path
+      IO.popen('xsel --clipboard --input', 'r+') { |clipboard| clipboard.puts(@file_path) }
+      BufferManager.flash "Copied file path to clipboard."
+    elsif system("which pbcopy > /dev/null 2>&1")
+      # mac path
+      IO.popen('pbcopy', 'r+') { |clipboard| clipboard.puts(@file_path) }
+      BufferManager.flash "Copied file path to clipboard."
+    else
+      BufferManager.flash "No way to copy text to clipboard - try installing xsel."
+    end
+  end
+
+  def run_async_hook
+    HookManager.run("async-edit", {:file_path => @file_path})
+  end
+
+  def file_being_edited?
+    # check for common editor lock files
+    vim_lock_file = File.join(File.dirname(@file_path), '.'+File.basename(@file_path)+'.swp')
+    emacs_lock_file = File.join(File.dirname(@file_path), '.#'+File.basename(@file_path))
+
+    return true if File.exist?(vim_lock_file) || File.exist?(emacs_lock_file)
+
+    false
+  end
+
+  def file_has_been_edited?
+    File.mtime(@file_path) > @orig_mtime
+  end
+
+end
+
+end