mail 2.2.4 → 2.2.5

data/CHANGELOG.rdoc

@@ -1,3 +1,9 @@
+== Thu 17 Jun 2010 22:13:18 UTC Mikel Lindsaar <mikel@rubyx.com>
+
+* Added Mail::POP3.delete_all, including specs (Martijn Storck)
+* Lars Pind updates on header folding
+* Version bump to 2.2.5
+
 == Tue Jun  8 01:55:21 UTC 2010 Mikel Lindsaar <mikel@rubyx.com>
 
 * Added inline attachment support to mail (mikel)

data/lib/VERSION

@@ -1,4 +1,4 @@
-patch:4
+patch:5
 major:2
 build:
 minor:2

data/lib/mail/encodings.rb

@@ -113,24 +113,34 @@ module Mail
     # 
     # String has to be of the format =?<encoding>?[QB]?<string>?=
     def Encodings.value_decode(str)
-      str = str.gsub(/\?=(\s*)=\?/, '?==?') # Remove whitespaces between 'encoded-word's
-
-      # Join QP encoded-words that are adjacent to avoid decoding partial chars
-      str.gsub!( /=\?==\?.+?\?[Qq]\?/m, '' ) if str =~ /\?==\?/
+      # Optimization: If there's no encoded-words in the string, just return it
+      return str unless str.index("=?")
       
-      str.gsub(/(.*?)(=\?.*?\?.\?.*?\?=)|$/m) do # Grab the insides of each encoded-word
-        before = $1.to_s
-        text = $2.to_s
+      str = str.gsub(/\?=(\s*)=\?/, '?==?') # Remove whitespaces between 'encoded-word's
 
-        case
-        when text.to_str =~ /=\?.+\?[Bb]\?/m
-          before + b_value_decode(text)
-        when text.to_str =~ /=\?.+\?[Qq]\?/m
-          before + q_value_decode(text)
+      # Split on white-space boundaries with capture, so we capture the white-space as well
+      str.split(/([ \t])/).map do |text|
+        if text.index('=?') != 0
+          text
         else
-          before + text
+          # Join QP encoded-words that are adjacent to avoid decoding partial chars
+          text.gsub!(/\?\=\=\?.+?\?[Qq]\?/m, '') if text =~ /\?==\?/
+        
+          # Separate encoded-words with a space, so we can treat them one by one
+          text.gsub!(/\?\=\=\?/, '?= =?')
+
+          text.split(/ /).map do |word|
+            case 
+            when word.to_str =~ /=\?.+\?[Bb]\?/m
+              b_value_decode(word)
+            when text.to_str =~ /=\?.+\?[Qq]\?/m
+              q_value_decode(word)
+            else
+              word.to_str
+            end
+          end
         end
-      end
+      end.join("")
     end
     
     # Takes an encoded string of the format =?<encoding>?[QB]?<string>?=
@@ -214,7 +224,7 @@ module Mail
     def Encodings.q_value_encode(str, encoding = nil)
       return str if str.to_s.ascii_only?
       string, encoding = RubyVer.q_value_encode(str, encoding)
-      string.gsub!("=\r\n=", '=') # We already have limited the string to the length we want
+      string.gsub!("=\r\n", '') # We already have limited the string to the length we want
       string.each_line.map do |str|
         "=?#{encoding}?Q?#{str.chomp.gsub(/ /, '_')}?="
       end.join(" ")

data/lib/mail/fields/unstructured_field.rb

@@ -102,64 +102,77 @@ module Mail
     #  it is allowed elsewhere.
     def wrapped_value # :nodoc:
       @folded_line = []
-      @unfolded_line = decoded.to_s.clone
+      @unfolded_line = decoded.to_s.split(/[ \t]/)
       fold("#{name}: ".length)
       wrap_lines(name, @folded_line)
     end
-
+   
+    # 6.2. Display of 'encoded-word's
+    # 
+    #  When displaying a particular header field that contains multiple
+    #  'encoded-word's, any 'linear-white-space' that separates a pair of
+    #  adjacent 'encoded-word's is ignored.  (This is to allow the use of
+    #  multiple 'encoded-word's to represent long strings of unencoded text,
+    #  without having to separate 'encoded-word's where spaces occur in the
+    #  unencoded text.)
     def wrap_lines(name, folded_lines)
       result = []
       index = 0
       result[index] = "#{name}: #{folded_lines.shift}"
-      folded_lines.each do |line|
-        if (result[index] + line).length < 77
-          result[index] << " " + line
-        else
-          result[index] << "\r\n\s"
-          index += 1
-          result[index] = line
-        end
-      end
-      result.join
+      result.concat(folded_lines)
+      result.join("\r\n\s")
     end
 
     def fold(prepend = 0) # :nodoc:
-      # Get the last whitespace character, OR we'll just choose 
-      # 78 if there is no whitespace, or 23 for non ascii:
-      # Each QP byte is 6 chars (=0A)
-      # Plus 18 for the =?encoding?Q?= ... ?=
-      # Plus 2 for the \r\n and 1 for the \s
-      # 80 - 2 - 1 - 18 = 59 / 6 ~= 10
-      @unfolded_line.ascii_only? ? (limit = 78 - prepend) : (limit = 10 - prepend)
-      # find the last white space character within the limit
-      if wspp = @unfolded_line.mb_chars.slice(0..limit) =~ /[ \t][^ \t]*$/
-        wrap = true
-        wspp = limit if wspp == 0
-        @folded_line << encode(@unfolded_line.mb_chars.slice!(0...wspp).strip.to_str)
-        @folded_line.flatten!
-      # if no last whitespace before the limit, find the first
-      elsif wspp = @unfolded_line.mb_chars =~ /[ \t][^ \t]/
-        wrap = true
-        wspp = limit if wspp == 0
-        @folded_line << encode(@unfolded_line.mb_chars.slice!(0...wspp).strip.to_str)
-        @folded_line.flatten!
-      # if no whitespace, don't wrap
-      else
-        wrap = false
-      end
-
-      if wrap && @unfolded_line.length > limit
-        fold
-      else
-        @folded_line << encode(@unfolded_line)
-        @folded_line.flatten!
+      encoding = @charset.to_s.upcase.gsub('_', '-')
+      while !@unfolded_line.empty?
+        encoded = false
+        limit = 78 - prepend
+        line = ""
+        while !@unfolded_line.empty?          
+          break unless word = @unfolded_line.first.dup
+          # Remember whether it was non-ascii before we encode it ('cause then we can't tell anymore)
+          non_ascii = word.not_ascii_only?
+          encoded_word = encode(word)
+          # Skip to next line if we're going to go past the limit
+          # Unless this is the first word, in which case we're going to add it anyway
+          # Note: This means that a word that's longer than 998 characters is going to break the spec. Please fix if this is a problem for you.
+          # (The fix, it seems, would be to use encoded-word encoding on it, because that way you can break it across multiple lines and 
+          # the linebreak will be ignored)
+          break if !line.empty? && (line.length + encoded_word.length + 1 > limit)
+          # If word was the first non-ascii word, we're going to make the entire line encoded and we're going to reduce the limit accordingly
+          if non_ascii && !encoded
+            encoded = true
+            encoded_word_safify!(line)
+            limit = limit - 8 - encoding.length  # minus the =?...?Q?...?= part, the possible leading white-space, and the name of the encoding
+          end
+          # Remove the word from the queue ...
+          @unfolded_line.shift
+          # ... add it in encoded form to the current line
+          line << " " unless line.empty?
+          encoded_word_safify!(encoded_word) if encoded
+          line << encoded_word          
+        end
+        # Add leading whitespace if both this and the last line were encoded, because whitespace between two encoded-words is ignored when decoding
+        line = " " + line if encoded && @folded_line.last && @folded_line.last.index('=?') == 0
+        # Encode the line if necessary
+        line = "=?#{encoding}?Q?#{line.gsub(/ /, '_')}?=" if encoded
+        # Add the line to the output and reset the prepend
+        @folded_line << line
+        prepend = 0
       end
     end
-
+        
     def encode(value)
-      value.gsub!("\r", "=0D")
-      value.gsub!("\n", "=0A")
-      Encodings.q_value_encode(value, @charset).split(" ")
+      (value.not_ascii_only? ? [value].pack("M").gsub("=\n", '') : value).gsub("\r", "=0D").gsub("\n", "=0A")
+    end
+    
+    def encoded_word_safify!(value)
+      value.gsub!(/"/,  '=22')
+      value.gsub!(/\(/, '=28')
+      value.gsub!(/\)/, '=29')
+      value.gsub!(/\?/, '=3F')
+      value.gsub!(/_/,  '=5F')
     end
 
   end

data/lib/mail/mail.rb

@@ -170,6 +170,13 @@ module Mail
     Mail.new(File.read(filename))
   end
   
+  # Delete all emails from a POP3 server.
+  # See Mail::POP3 for a complete documentation.
+  def Mail.delete_all(*args, &block)
+    retriever_method.delete_all(*args, &block)
+  end
+  
+  
   # Initialize the observers and interceptors arrays
   @@delivery_notification_observers = []
   @@delivery_interceptors = []

data/lib/mail/message.rb

@@ -1180,6 +1180,8 @@ module Mail
         self.body = value
       elsif name.to_s =~ /content[-_]type/i
         header[name] = value
+      elsif name.to_s == 'charset'
+        self.charset = value
       else
         header[name] = value
       end

data/lib/mail/network/retriever_methods/pop3.rb

@@ -118,6 +118,16 @@ module Mail
       end
     end
     
+    # Delete all emails from a POP3 server   
+    def delete_all
+      start do |pop3|
+        unless pop3.mails.empty?
+          pop3.delete_all
+          pop3.finish
+        end
+      end
+    end
+    
   private
   
     # Set default options

data/lib/mail/parts_list.rb

@@ -14,8 +14,17 @@ module Mail
         to_a
       end
     end
+    
+    undef :map
+    alias_method :map, :collect
 
-    alias :collect :map 
+    def map!
+      raise NoMethodError, "#map! is not defined, please call #collect and create a new PartsList"
+    end
+    
+    def collect!
+      raise NoMethodError, "#collect! is not defined, please call #collect and create a new PartsList"
+    end
     
     def sort!(order)
       sorted = self.sort do |a, b|

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 2
   - 2
-  - 4
-  version: 2.2.4
+  - 5
+  version: 2.2.5
 platform: ruby
 authors: 
 - Mikel Lindsaar
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-12 00:00:00 -07:00
+date: 2010-06-17 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency