sup 0.19.0

data/lib/sup/util/ncurses.rb

@@ -0,0 +1,274 @@
+require 'ncursesw'
+require 'sup/util'
+
+if defined? Ncurses
+module Ncurses
+
+  ## Helper class for storing keycodes
+  ## and multibyte characters.
+  class CharCode < String
+    ## Status code allows us to detect
+    ## printable characters and control codes.
+    attr_reader :status
+
+    ## Reads character from user input.
+    def self.nonblocking_getwch
+      # If we get input while we're shelled, we'll ignore it for the
+      # moment and use Ncurses.sync to wait until the shell_out is done.
+      begin
+        s, c = Redwood::BufferManager.shelled? ? Ncurses.sync { nil } : Ncurses.get_wch
+        break if s != Ncurses::ERR
+      end until IO.select([$stdin], nil, nil, 2)
+      [s, c]
+    end
+
+    ## Returns empty singleton.
+    def self.empty
+      Empty.instance
+    end
+
+    ## Creates new instance of CharCode
+    ## that keeps a given keycode.
+    def self.keycode(c)
+      generate c, Ncurses::KEY_CODE_YES
+    end
+
+    ## Creates new instance of CharCode
+    ## that keeps a printable character.
+    def self.character(c)
+      generate c, Ncurses::OK
+    end
+
+    ## Generates new object like new
+    ## but for empty or erroneous objects
+    ## it returns empty singleton.
+    def self.generate(c = nil, status = Ncurses::OK)
+      if status == Ncurses::ERR || c.nil? || c === Ncurses::ERR
+        empty
+      else
+        new(c, status)
+      end
+    end
+
+    ## Gets character from input.
+    ## Pretends ctrl-c's are ctrl-g's.
+    def self.get handle_interrupt=true
+      begin
+        status, code = nonblocking_getwch
+        generate code, status
+      rescue Interrupt => e
+        raise e unless handle_interrupt
+        keycode Ncurses::KEY_CANCEL
+      end
+    end
+
+    ## Enables dumb mode for any new instance.
+    def self.dumb!
+      @dumb = true
+    end
+
+    ## Asks if dumb mode was set
+    def self.dumb?
+      defined?(@dumb) && @dumb
+    end
+
+    def initialize(c = "", status = Ncurses::OK)
+      @status = status
+      c = "" if c.nil?
+      return super("") if status == Ncurses::ERR
+      c = enc_char(c) if c.is_a?(Fixnum)
+      super c.length > 1 ? c[0,1] : c
+    end
+
+    ## Proxy method for String's replace
+    def replace(c)
+      return self if c.object_id == object_id
+      if c.is_a?(self.class)
+        @status = c.status
+        super(c)
+      else
+        @status = Ncurses::OK
+        c = "" if c.nil?
+        c = enc_char(c) if c.is_a?(Fixnum)
+        super c.length > 1 ? c[0,1] : c
+      end
+    end
+
+    def to_character    ; character? ? self : "<#{code}>"           end  ## Returns character or code as a string
+    def to_keycode      ; keycode?   ? code : Ncurses::ERR          end  ## Returns keycode or ERR if it's not a keycode
+    def to_sequence     ; bytes.to_a                                end  ## Returns unpacked sequence of bytes for a character
+    def code            ; ord                                       end  ## Returns decimal representation of a character
+    def is_keycode?(c)  ; keycode?   &&  code == c                  end  ## Tests if keycode matches
+    def is_character?(c); character? &&  self == c                  end  ## Tests if character matches
+    def try_keycode     ; keycode?   ? code : nil                   end  ## Returns dec. code if keycode, nil otherwise
+    def try_character   ; character? ? self : nil                   end  ## Returns character if character, nil otherwise
+    def keycode         ; try_keycode                               end  ## Alias for try_keycode
+    def character       ; try_character                             end  ## Alias for try_character
+    def character?      ; dumb? || @status == Ncurses::OK           end  ## Returns true if character
+    def character!      ; @status  = Ncurses::OK ; self             end  ## Sets character flag
+    def keycode?        ; dumb? || @status == Ncurses::KEY_CODE_YES end  ## Returns true if keycode
+    def keycode!        ; @status  = Ncurses::KEY_CODE_YES ; self   end  ## Sets keycode flag
+    def keycode=(c)     ; replace(c); keycode! ; self               end  ## Sets keycode    
+    def present?        ; not empty?                                end  ## Proxy method
+    def printable?      ; character?                                end  ## Alias for character?
+    def dumb?           ; self.class.dumb?                          end  ## True if we cannot distinguish keycodes from characters
+
+    # Empty singleton that
+    # keeps GC from going crazy.
+    class Empty < CharCode
+      include Redwood::Singleton
+
+      ## Wrap methods that may change us
+      ## and generate new object instead.
+      [ :"[]=", :"<<", :replace, :insert, :prepend, :append, :concat, :force_encoding, :setbyte ].
+      select{ |m| public_method_defined?(m) }.
+      concat(public_instance_methods.grep(/!\z/)).
+      each do |m|
+        class_eval <<-EVAL
+          def #{m}(*args)
+            CharCode.new.#{m}(*args)
+          end
+        EVAL
+      end
+
+      ## proxy with class-level instance variable delegation
+      def self.dumb?
+        superclass.dumb? or !!@dumb
+      end
+
+      def self.empty
+        instance
+      end
+
+      def initialize
+        super("", Ncurses::ERR)
+      end
+
+      def empty?    ; true  end   ## always true
+      def present?  ; false end   ## always false
+      def clear     ; self  end   ## always self
+
+      self
+    end.init # CharCode::Empty
+
+    private
+
+    ## Tries to make external character right.
+    def enc_char(c)
+      begin
+        character = c.chr($encoding)
+      rescue RangeError, ArgumentError
+        begin
+          character = [c].pack('U')
+        rescue RangeError
+          begin
+            character = c.chr
+          rescue
+            begin
+              character = [c].pack('C')
+            rescue
+              character = ""
+              @status = Ncurses::ERR
+            end
+          end
+        end
+        character.fix_encoding!
+      end
+    end
+  end # class CharCode
+
+  def rows
+    lame, lamer = [], []
+    stdscr.getmaxyx lame, lamer
+    lame.first
+  end
+
+  def cols
+    lame, lamer = [], []
+    stdscr.getmaxyx lame, lamer
+    lamer.first
+  end
+
+  def curx
+    lame, lamer = [], []
+    stdscr.getyx lame, lamer
+    lamer.first
+  end
+
+  ## Create replacement wrapper for form_driver_w (), which is not (yet) a standard
+  ## function in ncurses. Some systems (Mac OS X) does not have a working
+  ## form_driver that accepts wide chars. We are just falling back to form_driver, expect problems.
+  def prepare_form_driver
+    if not defined? Form.form_driver_w
+      warn "Your Ncursesw does not have a form_driver_w function (wide char aware), " \
+           "non-ASCII chars may not work on your system."
+      Form.module_eval <<-FRM_DRV, __FILE__, __LINE__ + 1
+        def form_driver_w form, status, c
+          form_driver form, c
+        end
+        module_function :form_driver_w
+        module DriverHelpers
+          def form_driver c
+            if !c.dumb? && c.printable?
+              c.each_byte do |code|
+                Ncurses::Form.form_driver @form, code
+              end
+            else
+              Ncurses::Form.form_driver @form, c.code
+            end
+          end
+        end
+      FRM_DRV
+    end # if not defined? Form.form_driver_w
+    if not defined? Ncurses.get_wch
+      warn "Your Ncursesw does not have a get_wch function (wide char aware), " \
+           "non-ASCII chars may not work on your system."
+      Ncurses.module_eval <<-GET_WCH, __FILE__, __LINE__ + 1
+        def get_wch
+          c = getch
+          c == Ncurses::ERR ? [c, 0] : [Ncurses::OK, c]
+        end
+        module_function :get_wch
+      GET_WCH
+      CharCode.dumb!
+    end # if not defined? Ncurses.get_wch
+  end
+
+  def mutex; @mutex ||= Mutex.new; end
+  def sync &b; mutex.synchronize(&b); end
+
+  module_function :rows, :cols, :curx, :mutex, :sync, :prepare_form_driver
+
+  remove_const :KEY_ENTER
+  remove_const :KEY_CANCEL
+
+  KEY_ENTER = 10
+  KEY_CANCEL = 7 # ctrl-g
+  KEY_TAB = 9
+
+  module Form
+    ## This module contains helpers that ease
+    ## using form_driver_ methods when @form is present.
+    module DriverHelpers
+      private
+
+      ## Ncurses::Form.form_driver_w wrapper for keycodes and control characters.
+      def form_driver_key c
+        form_driver CharCode.keycode(c)
+      end
+
+      ## Ncurses::Form.form_driver_w wrapper for printable characters.
+      def form_driver_char c
+        form_driver CharCode.character(c)
+        #c.is_a?(Fixnum) ? c : c.ord
+      end
+
+      ## Ncurses::Form.form_driver_w wrapper for charcodes.
+      def form_driver c
+        Ncurses::Form.form_driver_w @form, c.status, c.code
+      end
+    end # module DriverHelpers
+  end # module Form
+
+end # module Ncurses
+end # if defined? Ncurses

data/lib/sup/util/path.rb

@@ -0,0 +1,9 @@
+module Redwood
+  module Util
+    module Path
+      def self.expand(path)
+        ::File.expand_path(path)
+      end
+    end
+  end
+end

data/lib/sup/util/query.rb

@@ -0,0 +1,17 @@
+module Redwood
+  module Util
+    module Query
+      class QueryDescriptionError < ArgumentError; end
+
+      def self.describe(query, fallback = nil)
+        d = query.description.force_encoding("UTF-8")
+
+        unless d.valid_encoding?
+          raise QueryDescriptionError.new(d) unless fallback
+          d = fallback
+        end
+        return d
+      end
+    end
+  end
+end

data/lib/sup/util/uri.rb

@@ -0,0 +1,15 @@
+require "uri"
+
+require "sup/util/path"
+
+module Redwood
+  module Util
+    module Uri
+      def self.build(components)
+        components = components.dup
+        components[:path] = Path.expand(components[:path])
+        ::URI::Generic.build(components)
+      end
+    end
+  end
+end

data/lib/sup/version.rb

@@ -0,0 +1,3 @@
+module Redwood
+  VERSION = "0.19.0"
+end

data/sup.gemspec

@@ -0,0 +1,53 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'sup/version'
+
+Gem::Specification.new do |s|
+  s.name = "sup"
+  s.version = ENV["REL"] || (::Redwood::VERSION == "git" ? "999" : ::Redwood::VERSION)
+  s.date = Time.now.strftime "%Y-%m-%d"
+  s.authors = ["William Morgan", "Gaute Hope", "Hamish Downer", "Matthieu Rakotojaona"]
+  s.email   = "supmua@googlegroups.com"
+  s.summary = "A console-based email client with the best features of GMail, mutt and Emacs"
+  s.homepage = "http://supmua.org"
+  s.license = 'GPL-2'
+  s.description = <<-DESC
+    Sup is a console-based email client for people with a lot of email.
+
+    * GMail-like thread-centered archiving, tagging and muting
+    * Handling mail from multiple mbox and Maildir sources
+    * Blazing fast full-text search with a rich query language
+    * Multiple accounts - pick the right one when sending mail
+    * Ruby-programmable hooks
+    * Automatically tracking recent contacts
+DESC
+  s.post_install_message = <<-EOF
+SUP: please note that our old mailing lists have been shut down,
+     re-subscribe to supmua@googlegroups.com to discuss and follow
+     updates on sup (send email to: supmua+subscribe@googlegroups.com).
+  EOF
+
+  s.files         = `git ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.add_runtime_dependency "xapian-ruby", "~> 1.2.15"
+  s.add_runtime_dependency "ncursesw", "~> 1.4.0"
+  s.add_runtime_dependency "rmail-sup", "~> 1.0.1"
+  s.add_runtime_dependency "highline"
+  s.add_runtime_dependency "trollop", ">= 1.12"
+  s.add_runtime_dependency "lockfile"
+  s.add_runtime_dependency "mime-types", "~> 1.0"
+  s.add_runtime_dependency "locale", "~> 2.0"
+  s.add_runtime_dependency "chronic", "~> 0.9.1"
+  s.add_runtime_dependency "unicode", "~> 0.4.4"
+
+  s.add_development_dependency "bundler", "~> 1.3"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "minitest", "~> 4.7"
+  s.add_development_dependency "rr", "~> 1.0.5"
+  s.add_development_dependency "gpgme", ">= 2.0.2"
+end

data/test/dummy_source.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/ruby
+
+require 'sup'
+require 'stringio'
+require 'rmail'
+require 'uri'
+
+module Redwood
+
+class DummySource < Source
+
+  attr_accessor :messages
+
+  def initialize uri, last_date=nil, usual=true, archived=false, id=nil, labels=[]
+    super uri, usual, archived, id
+    @messages = nil
+  end
+
+  def start_offset
+    0
+  end
+
+  def end_offset
+    # should contain the number of test messages -1
+    return @messages ? @messages.length - 1 : 0
+  end
+
+  def load_header offset
+    Source.parse_raw_email_header StringIO.new(raw_header(offset))
+  end
+
+  def load_message offset
+    RMail::Parser.read raw_message(offset)
+  end
+
+  def raw_header offset
+    ret = ""
+    f = StringIO.new(@messages[offset])
+    until f.eof? || (l = f.gets) =~ /^$/
+      ret += l
+    end
+    ret
+  end
+
+  def raw_message offset
+    @messages[offset]
+  end
+
+  def each_raw_message_line offset
+    ret = ""
+    f = StringIO.new(@messages[offset])
+    until f.eof?
+      yield f.gets
+    end
+  end
+end
+
+end
+
+# vim:noai:ts=2:sw=2:
+

data/test/gnupg_test_home/gpg.conf

@@ -0,0 +1 @@
+default-key 789E7011