sup 0.20.0 → 1.0

data/lib/sup/person.rb

@@ -18,11 +18,16 @@ class Person
     @email = email.strip.gsub(/\s+/, " ")
   end
 
-  def to_s; "#@name <#@email>" end
+  def to_s
+    if @name
+      "#@name <#@email>"
+    else
+      @email
+    end
+  end
 
 #   def == o; o && o.email == email; end
 #   alias :eql? :==
-#   def hash; [name, email].hash; end
 
   def shortname
     case @name
@@ -37,26 +42,10 @@ class Person
     end
   end
 
-  def longname
-    if @name && @email
-      "#@name <#@email>"
-    else
-      @email
-    end
-  end
-
   def mediumname; @name || @email; end
 
-  def Person.full_address name, email
-    if name && email
-      if name =~ /[",@]/
-        "#{name.inspect} <#{email}>" # escape quotes
-      else
-        "#{name} <#{email}>"
-      end
-    else
-      email
-    end
+  def longname
+    to_s
   end
 
   def full_address
@@ -79,56 +68,74 @@ class Person
     end.downcase
   end
 
-  ## return "canonical" person using contact manager or create one if
-  ## not found or contact manager not available
-  def self.from_name_and_email name, email
-    ContactManager.instantiated? && ContactManager.person_for(email) || Person.new(name, email)
+  def eql? o; email.eql? o.email end
+  def hash; email.hash end
+
+
+  ## see comments in self.from_address
+  def indexable_content
+    [name, email, email.split(/@/).first].join(" ")
   end
 
-  def self.from_address s
-    return nil if s.nil?
-
-    ## try and parse an email address and name
-    name, email = case s
-      when /(.+?) ((\S+?)@\S+) \3/
-        ## ok, this first match cause is insane, but bear with me.  email
-        ## addresses are stored in the to/from/etc fields of the index in a
-        ## weird format: "name address first-part-of-address", i.e.  spaces
-        ## separating those three bits, and no <>'s. this is the output of
-        ## #indexable_content. here, we reverse-engineer that format to extract
-        ## a valid address.
-        ##
-        ## we store things this way to allow searches on a to/from/etc field to
-        ## match any of those parts. a more robust solution would be to store a
-        ## separate, non-indexed field with the proper headers. but this way we
-        ## save precious bits, and it's backwards-compatible with older indexes.
-        [$1, $2]
-      when /["'](.*?)["'] <(.*?)>/, /([^,]+) <(.*?)>/
-        a, b = $1, $2
-        [a.gsub('\"', '"'), b]
-      when /<((\S+?)@\S+?)>/
-        [$2, $1]
-      when /((\S+?)@\S+)/
-        [$2, $1]
+  class << self
+
+    def full_address name, email
+      if name && email
+        if name =~ /[",@]/
+          "#{name.inspect} <#{email}>" # escape quotes
+        else
+          "#{name} <#{email}>"
+        end
       else
-        [nil, s]
+        email
       end
+    end
 
-    from_name_and_email name, email
-  end
+    ## return "canonical" person using contact manager or create one if
+    ## not found or contact manager not available
+    def from_name_and_email name, email
+      ContactManager.instantiated? && ContactManager.person_for(email) || Person.new(name, email)
+    end
 
-  def self.from_address_list ss
-    return [] if ss.nil?
-    ss.dup.split_on_commas.map { |s| self.from_address s }
-  end
+    def from_address s
+      return nil if s.nil?
+
+      ## try and parse an email address and name
+      name, email = case s
+        when /(.+?) ((\S+?)@\S+) \3/
+          ## ok, this first match cause is insane, but bear with me.  email
+          ## addresses are stored in the to/from/etc fields of the index in a
+          ## weird format: "name address first-part-of-address", i.e.  spaces
+          ## separating those three bits, and no <>'s. this is the output of
+          ## #indexable_content. here, we reverse-engineer that format to extract
+          ## a valid address.
+          ##
+          ## we store things this way to allow searches on a to/from/etc field to
+          ## match any of those parts. a more robust solution would be to store a
+          ## separate, non-indexed field with the proper headers. but this way we
+          ## save precious bits, and it's backwards-compatible with older indexes.
+          [$1, $2]
+        when /["'](.*?)["'] <(.*?)>/, /([^,]+) <(.*?)>/
+          a, b = $1, $2
+          [a.gsub('\"', '"'), b]
+        when /<((\S+?)@\S+?)>/
+          [$2, $1]
+        when /((\S+?)@\S+)/
+          [$2, $1]
+        else
+          [nil, s]
+        end
+
+      from_name_and_email name, email
+    end
+
+    def from_address_list ss
+      return [] if ss.nil?
+      ss.dup.split_on_commas.map { |s| self.from_address s }
+    end
 
-  ## see comments in self.from_address
-  def indexable_content
-    [name, email, email.split(/@/).first].join(" ")
   end
 
-  def eql? o; email.eql? o.email end
-  def hash; email.hash end
 end
 
 end

data/lib/sup/search.rb

@@ -12,7 +12,7 @@ class SearchManager
   def initialize fn
     @fn = fn
     @searches = {}
-    if File.exists? fn
+    if File.exist? fn
       IO.foreach(fn) do |l|
         l =~ /^([^:]*): (.*)$/ or raise "can't parse #{fn} line #{l.inspect}"
         @searches[$1] = $2

data/lib/sup/sent.rb

@@ -40,7 +40,7 @@ class SentLoader < MBox
 
   def initialize
     @filename = Redwood::SENT_FN
-    File.open(@filename, "w") { } unless File.exists? @filename
+    File.open(@filename, "w") { } unless File.exist? @filename
     super "mbox://" + @filename, true, $config[:archive_sent]
   end
 

data/lib/sup/source.rb

@@ -58,7 +58,7 @@ class Source
   attr_accessor :id
 
   def initialize uri, usual=true, archived=false, id=nil
-    raise ArgumentError, "id must be an integer: #{id.inspect}" unless id.is_a? Fixnum if id
+    raise ArgumentError, "id must be an integer: #{id.inspect}" unless id.is_a? Integer if id
 
     @uri = uri
     @usual = usual

data/lib/sup/util.rb

@@ -8,17 +8,9 @@ require 'set'
 require 'enumerator'
 require 'benchmark'
 require 'unicode'
+require 'unicode/display_width'
 require 'fileutils'
 
-## time for some monkeypatching!
-class Symbol
-  unless method_defined? :to_proc
-    def to_proc
-      proc {  |obj, *args| obj.send(self, *args) }
-    end
-  end
-end
-
 class Lockfile
   def gen_lock_id
     Hash[
@@ -89,7 +81,7 @@ module RMail
     end
 
     def charset
-      if header.field?("content-type") && header.fetch("content-type") =~ /charset="?(.*?)"?(;|$)/i
+      if header.field?("content-type") && header.fetch("content-type") =~ /charset\s*=\s*"?(.*?)"?(;|$)/i
         $1
       end
     end
@@ -170,13 +162,6 @@ module RMail
   end
 end
 
-class Range
-  ## only valid for integer ranges (unless I guess it's exclusive)
-  def size
-    last - first + (exclude_end? ? 0 : 1)
-  end
-end
-
 class Module
   def bool_reader *args
     args.each { |sym| class_eval %{ def #{sym}?; @#{sym}; end } }
@@ -198,17 +183,6 @@ class Module
 end
 
 class Object
-  def ancestors
-    ret = []
-    klass = self.class
-
-    until klass == Object
-      ret << klass
-      klass = klass.superclass
-    end
-    ret
-  end
-
   ## "k combinator"
   def returning x; yield x; x; end
 
@@ -266,21 +240,14 @@ end
 
 class String
   def display_length
-    @display_length ||= Unicode.width(self.fix_encoding!, false)
-
-    # if Unicode.width fails and returns -1, fall back to
-    # regular String#length, see pull-request: #256.
-    if @display_length < 0
-      @display_length = self.length
-    end
-
-    @display_length
+    @display_length ||= Unicode::DisplayWidth.of(self)
   end
 
   def slice_by_display_length len
     each_char.each_with_object "" do |c, buffer|
-      len -= c.display_length
-      buffer << c if len >= 0
+      len -= Unicode::DisplayWidth.of(c)
+      return buffer if len < 0
+      buffer << c
     end
   end
 
@@ -368,13 +335,14 @@ class String
     ret = []
     s = self
     while s.display_length > len
-      cut = s.slice_by_display_length(len).rindex(/\s/)
+      slice = s.slice_by_display_length(len)
+      cut = slice.rindex(/\s/)
       if cut
         ret << s[0 ... cut]
         s = s[(cut + 1) .. -1]
       else
-        ret << s.slice_by_display_length(len)
-        s = s[ret.last.length .. -1]
+        ret << slice
+        s = s[slice.length .. -1]
       end
     end
     ret << s
@@ -382,8 +350,6 @@ class String
 
   # Fix the damn string! make sure it is valid utf-8, then convert to
   # user encoding.
-  #
-  # Not Ruby 1.8 compatible
   def fix_encoding!
     # first try to encode to utf-8 from whatever current encoding
     encode!('UTF-8', :invalid => :replace, :undef => :replace)
@@ -406,8 +372,6 @@ class String
 
   # transcode the string if original encoding is know
   # fix if broken.
-  #
-  # Not Ruby 1.8 compatible
   def transcode to_encoding, from_encoding
     begin
       encode!(to_encoding, from_encoding, :invalid => :replace, :undef => :replace)
@@ -474,13 +438,6 @@ class String
     out = out.fix_encoding! # this should now be an utf-8 string of ascii
                            # compat chars.
   end
-
-  unless method_defined? :ascii_only?
-    def ascii_only?
-      size.times { |i| return false if self[i] & 128 != 0 }
-      return true
-    end
-  end
 end
 
 class Numeric
@@ -498,18 +455,18 @@ class Numeric
 
   def to_human_size
     if self < 1024
-      to_s + "b"
+      to_s + "B"
     elsif self < (1024 * 1024)
-      (self / 1024).to_s + "k"
+      (self / 1024).to_s + "KiB"
     elsif self < (1024 * 1024 * 1024)
-      (self / 1024 / 1024).to_s + "m"
+      (self / 1024 / 1024).to_s + "MiB"
     else
-      (self / 1024 / 1024 / 1024).to_s + "g"
+      (self / 1024 / 1024 / 1024).to_s + "GiB"
     end
   end
 end
 
-class Fixnum
+class Integer
   def to_character
     if self < 128 && self >= 0
       chr
@@ -518,12 +475,6 @@ class Fixnum
     end
   end
 
-  unless method_defined?(:ord)
-    def ord
-      self
-    end
-  end
-
   ## hacking the english language
   def pluralize s
     to_s + " " +
@@ -607,10 +558,6 @@ module Enumerable
   end
 end
 
-unless Object.const_defined? :Enumerator
-  Enumerator = Enumerable::Enumerator
-end
-
 class Array
   def flatten_one_level
     inject([]) { |a, e| a + e }
@@ -706,32 +653,6 @@ class SavingHash
   defer_all_other_method_calls_to :hash
 end
 
-class OrderedHash < Hash
-  alias_method :store, :[]=
-  alias_method :each_pair, :each
-  attr_reader :keys
-
-  def initialize *a
-    @keys = []
-    a.each { |k, v| self[k] = v }
-  end
-
-  def []= key, val
-    @keys << key unless member?(key)
-    super
-  end
-
-  def values; keys.map { |k| self[k] } end
-  def index key; @keys.index key end
-
-  def delete key
-    @keys.delete key
-    super
-  end
-
-  def each; @keys.each { |k| yield k, self[k] } end
-end
-
 ## easy thread-safe class for determining who's the "winner" in a race (i.e.
 ## first person to hit the finish line
 class FinishLine

data/lib/sup/util/axe.rb

@@ -0,0 +1,17 @@
+require 'highline'
+@cli = HighLine.new
+
+def axe q, default=nil
+  question = if default && !default.empty?
+               "#{q} (enter for \"#{default}\"): "
+             else
+               "#{q}: "
+             end
+  ans = @cli.ask question
+  ans.empty? ? default : ans.to_s
+end
+
+def axe_yes q, default="n"
+  axe(q, default) =~ /^y|yes$/i
+end
+

data/lib/sup/util/locale_fiddler.rb

@@ -0,0 +1,24 @@
+## the following magic enables wide characters when used with a ruby
+## ncurses.so that's been compiled against libncursesw. (note the w.) why
+## this works, i have no idea. much like pretty much every aspect of
+## dealing with curses.  cargo cult programming at its best.
+require 'fiddle'
+require 'fiddle/import'
+
+module LocaleFiddler
+  extend Fiddle::Importer
+
+  SETLOCALE_LIB = case RbConfig::CONFIG['arch']
+                  when /darwin/; "libc.dylib"
+                  when /cygwin/; "cygwin1.dll"
+                  when /freebsd/; "libc.so.7"
+                  else; "libc.so.6"
+                  end
+
+  dlload SETLOCALE_LIB
+  extern "char *setlocale(int, char const *)"
+
+  def setlocale(type, string)
+    LocaleFiddler.setlocale(type, string)
+  end
+end

data/lib/sup/util/ncurses.rb

@@ -76,7 +76,7 @@ module Ncurses
       @status = status
       c = "" if c.nil?
       return super("") if status == Ncurses::ERR
-      c = enc_char(c) if c.is_a?(Fixnum)
+      c = enc_char(c) if c.is_a?(Integer)
       super c.length > 1 ? c[0,1] : c
     end
 
@@ -89,7 +89,7 @@ module Ncurses
       else
         @status = Ncurses::OK
         c = "" if c.nil?
-        c = enc_char(c) if c.is_a?(Fixnum)
+        c = enc_char(c) if c.is_a?(Integer)
         super c.length > 1 ? c[0,1] : c
       end
     end
@@ -260,7 +260,7 @@ module Ncurses
       ## 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
+        #c.is_a?(Integer) ? c : c.ord
       end
 
       ## Ncurses::Form.form_driver_w wrapper for charcodes.