maildir 0.3.0 → 0.4.0

data/.gitignore

@@ -1,2 +1,3 @@
 pkg/*
 benchmarks/scratch.rb
+.DS_Store

data/README.rdoc

@@ -85,13 +85,15 @@ Maildir::Serializer::Base simply reads and writes strings to disk.
 
 The Mail serializer takes a ruby Mail object (http://github.com/mikel/mail) and writes RFC2822 email messages.
 
+  require 'maildir/serializer/mail'
   Maildir::Message.serializer = Maildir::Serializer::Mail.new
   mail = Mail.new(...)
-  message = maildir.add(mail) # writes and RFC2822 message to disk
+  message = maildir.add(mail) # writes an RFC2822 message to disk
   message.data == mail # => true; data is parsed as a Mail object
 
-The Marshal, JSON, and YAML serializers work similarly. E.g.
+The Marshal, JSON, and YAML serializers work similarly. E.g.:
 
+  require 'maildir/serializer/json'
   Maildir::Message.serializer = Maildir::Serializer::JSON.new
   my_data = {"foo" => nil, "my_array" => [1,2,3]}
   message = maildir.add(my_data) # writes {"foo":null,"my_array":[1,2,3]}
@@ -102,6 +104,10 @@ It's trivial to create a custom serializer. Implement the following two methods:
   load(path)
   dump(data, path)
 
+== Credits
+
+niklas | brueckenschlaeger, http://github.com/nilclass added subdir & courierimapkeywords support
+
 == Copyright
 
 Copyright (c) 2010 Aaron Suggs. See LICENSE for details.

data/Rakefile

@@ -19,6 +19,7 @@ begin
     gemspec.add_development_dependency "shoulda", ">= 0"
     gemspec.add_development_dependency "mail", ">= 0"
     gemspec.add_development_dependency "json", ">= 0"
+    gemspec.add_development_dependency "ktheory-fakefs", ">= 0"
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/lib/maildir.rb

@@ -11,7 +11,9 @@ class Maildir
   # Create a new maildir at +path+. If +create+ is true, will ensure that the
   # required subdirectories exist.
   def initialize(path, create = true)
-    @path = File.join(path, '/') # Ensure path has a trailing slash
+    @path = File.expand_path(path)
+    @path = File.join(@path, '/') # Ensure path has a trailing slash
+    @path_regexp = /^#{Regexp.quote(@path)}/ # For parsing directory listings
     create_directories if create
   end
 
@@ -25,6 +27,11 @@ class Maildir
     self.path <=> maildir.path
   end
 
+  # Friendly inspect method
+  def inspect
+    "#<#{self.class} path=#{@path}>"
+  end
+
   # define methods tmp_path, new_path, & cur_path
   SUBDIRS.each do |subdir|
     define_method "#{subdir}_path" do
@@ -37,7 +44,8 @@ class Maildir
   # exist.
   def create_directories
     SUBDIRS.each do |subdir|
-      FileUtils.mkdir_p(self.send("#{subdir}_path"))
+      subdir_path = File.join(path, subdir.to_s)
+      FileUtils.mkdir_p(subdir_path)
     end
   end
 
@@ -47,26 +55,24 @@ class Maildir
   # E.g.
   #  maildir.list(:new) # => all new messages
   #  maildir.list(:cur, :limit => 10) # => 10 oldest messages in cur
-  def list(new_or_cur, options = {})
-    new_or_cur = new_or_cur.to_sym
-    unless [:new, :cur].include? new_or_cur
-      raise ArgumentError, "first arg must be new or cur"
+  def list(dir, options = {})
+    unless SUBDIRS.include? dir.to_sym
+      raise ArgumentError, "dir must be :new, :cur, or :tmp"
     end
 
-    keys = get_dir_listing(new_or_cur)
-
-    # Map keys to message objects
-    messages = keys.map{|key| get(key)}
+    keys = get_dir_listing(dir)
 
-    # Sort the messages (effectively chronological order)
+    # Sort the keys (chronological order)
     # TODO: make sorting configurable
-    messages.sort!
+    keys.sort!
 
-    # Apply the limit
+    # Apply the limit after sorting
     if limit = options[:limit]
-      messages = messages[0,limit]
+      keys = keys[0,limit]
     end
-    messages
+
+    # Map keys to message objects
+    keys.map{|key| get(key)}
   end
 
   # Writes data object out as a new message. Returns a Maildir::Message. See
@@ -75,19 +81,32 @@ class Maildir
     Maildir::Message.create(self, data)
   end
 
+  # Returns a message object for key
   def get(key)
     Maildir::Message.new(self, key)
   end
 
+  # Deletes the message for key by calling destroy() on the message.
+  def delete(key)
+    get(key).destroy
+  end
+
+  # Finds messages in the tmp folder that have not been modified since
+  # +time+. +time+ defaults to 36 hours ago.
+  def get_stale_tmp(time = Time.now - 129600)
+    list(:tmp).select do |message|
+      (mtime = message.mtime) && mtime < time
+    end
+  end
+
   protected
-  def get_dir_listing(new_or_cur)
-    search_path = File.join(self.path, new_or_cur.to_s, '*')
-    results = Dir.glob(search_path)
-
-    # Remove the maildir's path from the beginning of the message path
-    @dir_listing_regexp ||= /^#{Regexp.quote(self.path)}/
-    results.each do |message_path|
-      message_path.sub!(@dir_listing_regexp, "")
+  # Returns an array of keys in dir
+  def get_dir_listing(dir)
+    search_path = File.join(self.path, dir.to_s, '*')
+    keys = Dir.glob(search_path)
+    #  Remove the maildir's path from the keys
+    keys.each do |key|
+      key.sub!(@path_regexp, "")
     end
   end
 end

data/lib/maildir/keywords.rb

@@ -0,0 +1,103 @@
+# implements IMAP Keywords as used by the Courier Mail Server
+# see http://www.courier-mta.org/imap/README.imapkeywords.html for details
+
+require 'ftools'
+require 'maildir'
+module Maildir::Keywords
+  def self.included(base)
+    Maildir::Message.send(:include, MessageExtension)
+  end
+
+  # process contents of courierimapkeywords/ directory as described in README.imapkeywords
+  def read_keywords
+    messages = (list(:cur) + list(:new)).inject({}) { |m, msg| m[msg.unique_name] = msg ; m }
+    t = Time.now.to_i / 300
+    keyword_dir = File.join(path, 'courierimapkeywords')
+    keywords = []
+    state = :head
+    # process :list
+    File.open(File.join(keyword_dir, ':list')).each_line do |line|
+      line.strip!
+      if state == :head
+        if line.empty?
+          state = :messages
+          next
+        end
+        keywords << line
+      else
+        key, ids = line.split(':')
+        if msg = messages[key]
+          msg.set_keywords(ids.split(/\s/).map {|id| keywords[id.to_i - 1] })
+        end
+      end
+    end
+    # collect keyword files
+    keyword_files = (Dir.entries(keyword_dir) - %w(. .. :list)).inject({}) do |keyword_files, file|
+      if file =~ /^\.(\d+)\.(.*)$/
+        n = $1
+        key = $2
+      else
+        n = t + 1
+        key = file
+        File.move(File.join(keyword_dir, file), File.join(keyword_dir, ".#{n}.#{key}"))
+      end
+      if msg = messages[key]
+        (keyword_files[key] ||= []) << [n, key]
+      else # message doesn't exist
+        fname = File.join(keyword_dir, file)
+        if File.stat(fname).ctime < (Time.now - (15 * 60))
+          File.unlink(fname)
+        end
+      end
+    end
+    # process keyword files
+    keyword_files.each_pair do |key, files|
+      files.sort! { |a, b| a[0] <=> b[0] }
+      files[0..-2].each { |f| File.unlink(File.join(keyword_dir, ".#{f.join('.')}")) } if n_files.last[0] < t
+      msg = messages[key]
+      current_keywords = File.read(files.last).read.split(/\s+/)
+      msg.set_keywords(current_keywords)
+      if (add = (current_keywords - keywords)).any?
+        keywords += add
+      end
+    end
+    # rebuild :list
+    @keywords = {}
+    tmp_file = File.join(path, 'tmp', ':list')
+    File.open(tmp_file, 'w') { |f|
+      f.write(keywords.join("\n")+"\n\n")
+      messages.each_pair do |key, msg|
+        next unless msg.keywords
+        f.puts([key, msg.keywords.map{|kw| keywords.index(kw) + 1 }.sort.join(' ')].join(':'))
+        @keywords[key] = msg.keywords
+      end
+    }
+    File.move(tmp_file, File.join(keyword_dir, ':list'))
+  end
+
+  def keywords(key)
+    read_keywords unless @keywords
+    @keywords[key] || []
+  end
+
+  module MessageExtension
+    def keywords
+      return @keywords if @keywords
+      @maildir.keywords(unique_name)
+    end
+
+    # sets given keywords on the message.
+    def keywords=(list)
+      tmp_fname = File.join(maildir.path, 'tmp', unique_name)
+      File.open(tmp_fname, 'w') { |f| f.write(list.join("\n")) }
+      File.move(tmp_fname, File.join(maildir.path, 'courierimapkeywords', unique_name))
+    end
+
+    # sets @keywords to the given list
+    def set_keywords(list)
+      @keywords = list
+    end
+  end
+end
+
+Maildir.send(:include, Maildir::Keywords)

data/lib/maildir/message.rb

@@ -6,27 +6,33 @@ class Maildir::Message
 
   include Comparable
 
-  class << self
-    # Create a new message in maildir with data.
-    # The message is first written to the tmp dir, then moved to new. This is
-    # a shortcut for:
-    #   message = Maildir::Message.new(maildir)
-    #   message.write(data)
-    def create(maildir, data)
-      message = self.new(maildir)
-      message.write(data)
-      message
-    end
+  # Create a new message in maildir with data.
+  # The message is first written to the tmp dir, then moved to new. This is
+  # a shortcut for:
+  #   message = Maildir::Message.new(maildir)
+  #   message.write(data)
+  def self.create(maildir, data)
+    message = self.new(maildir)
+    message.write(data)
+    message
+  end
+
+  # The serializer processes data before it is written to disk and after
+  # reading from disk.
+  # Default serializer
+  @@serializer = Maildir::Serializer::Base.new
 
-    # The serializer processes data before it is written to disk and after
-    # reading from disk.
-    attr_accessor :serializer
+  # Get the serializer
+  def self.serializer
+    @@serializer
   end
 
-  # Default serializer
-  @serializer = Maildir::Serializer::Base.new
+  # Set the serializer
+  def self.serializer=(serializer)
+    @@serializer = serializer
+  end
 
-  attr_reader :dir, :unique_name, :info, :old_key
+  attr_reader :dir, :unique_name, :info
 
   # Create a new, unwritten message or instantiate an existing message.
   # If key is nil, create a new message:
@@ -39,6 +45,7 @@ class Maildir::Message
     @maildir = maildir
     if key.nil?
       @dir = :tmp
+      @unique_name = Maildir::UniqueName.create
     else
       parse_key(key)
     end
@@ -46,10 +53,6 @@ class Maildir::Message
     unless Maildir::SUBDIRS.include? dir
       raise ArgumentError, "State must be in #{Maildir::SUBDIRS.inspect}"
     end
-
-    if :tmp == dir
-      @unique_name = Maildir::UniqueName.create
-    end
   end
 
   # Compares messages by their paths.
@@ -62,9 +65,14 @@ class Maildir::Message
     self.path <=> message.path
   end
 
+  # Friendly inspect method
+  def inspect
+    "#<#{self.class} key=#{key} maildir=#{@maildir.inspect}>"
+  end
+
   # Returns the class' serializer
   def serializer
-    self.class.serializer
+    @@serializer
   end
 
   # Writes data to disk. Can only be called on messages instantiated without
@@ -88,32 +96,53 @@ class Maildir::Message
   end
 
   # Set info on a message.
-  # Returns the message's key
+  # Returns the message's key if successful, false otherwise.
   def info=(info)
     raise "Can only set info on cur messages" unless :cur == @dir
     rename(:cur, info)
   end
 
+  FLAG_NAMES = {
+    :passed => 'P',
+    :replied => 'R',
+    :seen => 'S',
+    :trashed => 'T',
+    :draft => 'D',
+    :flagged => 'F'
+  }
+
+  FLAG_NAMES.each_pair do |key, value|
+    define_method("#{key}?".to_sym) do
+      flags.include?(value)
+    end
+    define_method("#{key}!".to_sym) do
+      add_flag(value)
+    end
+  end
+
   # Returns an array of single letter flags applied to the message
   def flags
     @info.sub(INFO,'').split('')
   end
 
   # Sets the flags on a message.
-  # Returns the message's key
+  # Returns the message's key if successful, false otherwise.
   def flags=(*flags)
     self.info = INFO + sort_flags(flags.flatten.join(''))
   end
 
+  # Adds a flag to a message.
+  # Returns the message's key if successful, false otherwise.
   def add_flag(flag)
     self.flags = (flags << flag.upcase)
   end
-  
+
+  # Removes a flag from a message.
+  # Returns the message's key if successful, false otherwise.
   def remove_flag(flag)
     self.flags = flags.delete_if{|f| f == flag.upcase}
   end
 
-
   # Returns the filename of the message
   def filename
     [unique_name, info].compact.join(COLON)
@@ -129,19 +158,55 @@ class Maildir::Message
     File.join(@maildir.path, key)
   end
 
-  # Returns the message's data from disk
+  # Returns the message's data from disk.
+  # If the path doesn't exist, freeze's the object and raises Errno:ENOENT
   def data
-    serializer.load(path)
+    guard(true) { serializer.load(path) }
+  end
+
+  # Updates the modification and access time. Returns 1 if successful, false
+  # otherwise.
+  def utime(atime, mtime)
+    guard { File.utime(atime, mtime, path) }
+  end
+
+  # Returns the message's atime, or false if the file doesn't exist.
+  def atime
+    guard { File.atime(path) }
+  end
+
+  # Returns the message's mtime, or false if the file doesn't exist.
+  def mtime
+    guard { File.mtime(path) }
   end
 
   # Deletes the message path and freezes the message object
   def destroy
-    File.delete(path)
+    guard { File.delete(path) }
     freeze
   end
 
   protected
 
+  # Guard access to the file system by rescuing Errno::ENOENT, which happens
+  # if the file is missing. When +blocks+ fails and +reraise+ is false, returns
+  # false, otherwise reraises Errno::ENOENT
+  def guard(reraise = false, &block)
+    begin
+      yield
+    rescue Errno::ENOENT
+      if @old_key
+        # Restore ourselves to the old state
+        parse_key(@old_key)
+      end
+
+      # Don't allow further modifications
+      freeze
+
+      reraise ? raise : false
+    end
+  end
+
   # Sets dir, unique_name, and info based on the key
   def parse_key(key)
     @dir, filename = key.split(File::SEPARATOR)
@@ -155,24 +220,22 @@ class Maildir::Message
   end
 
   def old_path
-    File.join(@maildir.path, old_key)
+    File.join(@maildir.path, @old_key)
   end
 
+  # Renames the message. Returns the new key if successful, false otherwise.
   def rename(new_dir, new_info=nil)
-    # Safe the old key so we can revert to the old state
+    # Save the old key so we can revert to the old state
     @old_key = key
 
     # Set the new state
     @dir = new_dir
     @info = new_info if new_info
 
-    begin
+    guard do
       File.rename(old_path, path) unless old_path == path
+      @old_key = nil # So guard() doesn't reset to a bad state
       return key
-    rescue Errno::ENOENT
-      # Restore ourselves to the old state
-      parse_key(@old_key)
-      raise
     end
   end
 end

data/lib/maildir/subdirs.rb

@@ -0,0 +1,65 @@
+# implements subdirs as used by the Courier Mail Server (courier-mta.org)
+require 'maildir'
+module Maildir::Subdirs
+  ROOT_NAME = 'INBOX'
+  DELIM = '.'
+
+  def self.included(base)
+    base.instance_eval do 
+      alias_method :inspect_without_subdirs, :inspect
+      alias_method :inspect, :inspect_with_subdirs
+    end
+  end
+
+  def create_subdir(name)
+    raise ArgumentError.new("'name' may not contain delimiter character (#{DELIM})") if name.include?(DELIM)
+    full_name = (root? ? [] : subdir_parts(File.basename(path))).push(name).unshift('').join(DELIM)
+    md = Maildir.new(File.join(path, full_name), true)
+    @subdirs << md if @subdirs
+    md
+  end
+
+  # returns the logical mailbox path
+  def mailbox_path
+    @mailbox_path ||= root? ? ROOT_NAME : subdir_parts(File.basename(path)).unshift(ROOT_NAME).join(DELIM)
+  end
+
+  # returns an array of Maildir objects representing the direct subdirectories of this Maildir
+  def subdirs(only_direct=true)
+    if root?
+      @subdirs ||= (Dir.entries(path) - %w(. ..)).select {|e|
+        e =~ /^\./ && File.directory?(File.join(path, e)) && (only_direct ? subdir_parts(e).size == 1 : true)
+      }.map { |e| Maildir.new(File.join(path, e), false) }
+    else
+      my_parts = subdir_parts(File.basename(path))
+      @subdirs ||= root.subdirs(false).select { |md| subdir_parts(File.basename(md.path))[0..-2] == my_parts }
+    end
+  end
+  
+  # Friendly inspect method
+  def inspect_with_subdirs
+    "#<#{self.class} path=#{@path} mailbox_path=#{mailbox_path}>"
+  end
+
+  # returns the Maildir representing the root directory
+  def root
+    root? ? self : Maildir.new(File.dirname(path), false)
+  end
+
+  # returns true if the parent directory doesn't look like a maildir
+  def root?
+    ! ((Dir.entries(File.dirname(path)) & %w(cur new tmp)).size == 3)
+  end
+
+  private
+
+  def subdir_parts(path)
+    parts = (path.split(DELIM) - [''])
+    # some clients (e.g. Thunderbird) mess up namespaces so subdirs
+    # end up looking like '.INBOX.Trash' instead of '.Trash'
+    parts.shift if parts.first == ROOT_NAME
+    parts
+  end
+end
+
+Maildir.send(:include, Maildir::Subdirs)

data/maildir.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{maildir}
-  s.version = "0.3.0"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Aaron Suggs"]
-  s.date = %q{2010-01-08}
+  s.date = %q{2010-01-24}
   s.description = %q{A ruby library for reading and writing arbitrary messages in DJB's maildir format}
   s.email = %q{aaron@ktheory.com}
   s.extra_rdoc_files = [
@@ -24,12 +24,14 @@ Gem::Specification.new do |s|
      "VERSION",
      "benchmarks/runner",
      "lib/maildir.rb",
+     "lib/maildir/keywords.rb",
      "lib/maildir/message.rb",
      "lib/maildir/serializer/base.rb",
      "lib/maildir/serializer/json.rb",
      "lib/maildir/serializer/mail.rb",
      "lib/maildir/serializer/marshal.rb",
      "lib/maildir/serializer/yaml.rb",
+     "lib/maildir/subdirs.rb",
      "lib/maildir/unique_name.rb",
      "maildir.gemspec",
      "test/test_helper.rb",
@@ -59,15 +61,18 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_development_dependency(%q<mail>, [">= 0"])
       s.add_development_dependency(%q<json>, [">= 0"])
+      s.add_development_dependency(%q<ktheory-fakefs>, [">= 0"])
     else
       s.add_dependency(%q<shoulda>, [">= 0"])
       s.add_dependency(%q<mail>, [">= 0"])
       s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<ktheory-fakefs>, [">= 0"])
     end
   else
     s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<mail>, [">= 0"])
     s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<ktheory-fakefs>, [">= 0"])
   end
 end
 

data/test/test_helper.rb

@@ -1,24 +1,26 @@
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
-require 'tmpdir'
-require 'tempfile'
 require 'fileutils'
 require 'maildir'
 
+# Require all the serializers
+serializers = File.join(File.dirname(__FILE__), "..","lib","maildir","serializer","*")
+Dir.glob(serializers).each do |serializer|
+  require serializer
+end
+
+# Require 'ktheory-fakefs' until issues 28, 29, and 30 are resolved in
+# defunkt/fakefs. See http://github.com/defunkt/fakefs/issues
+gem "ktheory-fakefs"
+require 'fakefs'
+
 # Create a reusable maildir that's cleaned up when the tests are done
 def temp_maildir
-  return $maildir if $maildir
-  
-  dir_path = Dir.mktmpdir("maildir_test")
-  at_exit do
-    puts "Cleaning up temp maildir"
-    FileUtils.rm_r(dir_path)
-  end
-  $maildir = Maildir.new(dir_path)
+  Maildir.new("/tmp/maildir_test")
 end
 
 # Useful for testing that strings defined & not empty
 def assert_not_empty(obj, msg='')
   assert !obj.nil? && !obj.empty?, msg
-end
+end

data/test/test_maildir.rb

@@ -2,6 +2,10 @@ require 'test_helper'
 class TestMaildir < Test::Unit::TestCase
 
   context "A maildir" do
+    setup do
+      FakeFS::FileSystem.clear
+    end
+
     should "have a path" do
       assert_not_empty temp_maildir.path
     end
@@ -13,31 +17,38 @@ class TestMaildir < Test::Unit::TestCase
       end
     end
 
+    should "expand paths" do
+      maildir = Maildir.new("~/test_maildir/")
+      expanded_path = File.expand_path("~/test_maildir")
+      expanded_path = File.join(expanded_path, "/")
+      assert_equal expanded_path, maildir.path
+    end
+
     should "not create directories if specified" do
-      tmp_dir = Dir.mktmpdir('new_maildir_test')
-      maildir = Maildir.new(tmp_dir, false)
+      maildir = Maildir.new("/maildir_without_subdirs", false)
       %w(tmp new cur).each do |subdir|
         subdir_path = maildir.send("#{subdir}_path")
         assert !File.directory?(subdir_path), "Subdir #{subdir} exists"
       end
-      FileUtils.rm_r(tmp_dir)
     end
-    
+
     should "be identical to maildirs with the same path" do
       new_maildir = Maildir.new(temp_maildir.path)
       assert_equal temp_maildir.path, new_maildir.path
       assert_equal temp_maildir, new_maildir
     end
-    
-    context "with a message" do
-      setup do
-        @message = temp_maildir.add("")
-      end
 
-      should "list the message in it's keys" do
-        messages = temp_maildir.list(:new)
-        assert_equal messages, [@message]
-      end
+    should "list a new message" do
+      @message = temp_maildir.add("")
+      messages = temp_maildir.list(:new)
+      assert_equal messages, [@message]
+    end
+
+    should "list a cur message" do
+      @message = temp_maildir.add("")
+      @message.process
+      messages = temp_maildir.list(:cur)
+      assert_equal messages, [@message]
     end
   end
 
@@ -48,4 +59,15 @@ class TestMaildir < Test::Unit::TestCase
     end
   end
 
+  context "Maildirs with stale messages in tmp" do
+    should "be found" do
+      stale_path = File.join(temp_maildir.path, "tmp", "stale_message")
+      File.open(stale_path, "w"){|f| f.write("")}
+      stale_time = Time.now - 30*24*60*60 # 1 month ago
+      File.utime(stale_time, stale_time, stale_path)
+
+      stale_tmp = [temp_maildir.get("tmp/stale_message")]
+      assert_equal stale_tmp, temp_maildir.get_stale_tmp
+    end
+  end
 end

data/test/test_message.rb

@@ -3,13 +3,10 @@ class TestMessage < Test::Unit::TestCase
 
   context "An new, unwritten message" do
     setup do
+      FakeFS::FileSystem.clear
       @message = Maildir::Message.new(temp_maildir)
     end
 
-    should "be instantiated" do
-      assert @message
-    end
-
     should "be in :tmp" do
       assert_equal :tmp, @message.dir
       assert_match(/tmp/, @message.path)
@@ -32,138 +29,198 @@ class TestMessage < Test::Unit::TestCase
         @message.info= "2,FRS"
       end
     end
+  end
 
-    context "when written with a string" do
-      setup do
-        @data = "foo\n"
-        @message.write(@data)
-      end
+  context "A written message" do
+    setup do
+      FakeFS::FileSystem.clear
+      @message = Maildir::Message.new(temp_maildir)
+      @data = "foo"
+      @message.write(@data)
+    end
 
-      should "not be writable" do
-        assert_raise RuntimeError do
-          @message.write("nope!")
-        end
+    should "not be writable" do
+      assert_raise RuntimeError do
+        @message.write("nope!")
       end
+    end
 
-      should "have no info" do
-        assert_nil @message.info
-      end
+    should "have no info" do
+      assert_nil @message.info
+    end
 
-      should "not be able to set info" do
-        assert_raises RuntimeError do
-          @message.info= "2,FRS"
-        end
+    should "not be able to set info" do
+      assert_raises RuntimeError do
+        @message.info= "2,FRS"
       end
+    end
 
-      should "be in new dir" do
-        assert_equal :new, @message.dir
-        assert_match(/new/, @message.path)
-      end
+    should "be in new" do
+      assert_equal :new, @message.dir
+      assert_match(/new/, @message.path)
+    end
 
-      should "have have a file" do
-        assert File.exists?(@message.path)
-      end
+    should "have a file" do
+      assert File.exists?(@message.path)
+    end
 
-      should "have the correct data" do
-        assert_equal @data, @message.data
-      end
+    should "have the correct data" do
+      assert_equal @data, @message.data
     end
   end
 
-  context "A created message" do
+  context "A processed message" do
     setup do
-      @data = "foo\n"
+      FakeFS::FileSystem.clear
+      @data = "foo"
       @message = Maildir::Message.create(temp_maildir, @data)
+      @message.process
     end
 
-    should "have the correct data" do
-      assert_equal @data, @message.data
-    end
-
-    context "when processed" do
-      setup do
-        @message.process
+    should "not be writable" do
+      assert_raise RuntimeError do
+        @message.write("nope!")
       end
+    end
 
-      should "not be writable" do
-        assert_raise RuntimeError do
-          @message.write("nope!")
-        end
-      end
+    should "be in cur" do
+      assert_equal :cur, @message.dir
+    end
 
-      should "be in cur" do
-        assert_equal :cur, @message.dir
-      end
+    should "have info" do
+      assert_equal Maildir::Message::INFO, @message.info
+    end
 
-      should "have info" do
-        assert_equal Maildir::Message::INFO, @message.info
-      end
+    should "set info" do
+      info = "2,FRS"
+      @message.info = "2,FRS"
+      assert_equal @message.info, info
+      assert_match /#{info}$/, @message.path
+    end
 
-      should "set info" do
-        info = "2,FRS"
-        @message.info = "2,FRS"
-        assert_equal @message.info, info
-        assert_match /#{info}$/, @message.path
-      end
+    should "add and remove flags" do
+      @message.add_flag('S')
+      assert_equal ['S'], @message.flags
 
-      should "add and remove flags" do
-        @message.add_flag('S')
-        assert_equal ['S'], @message.flags
+      # Test lowercase
+      @message.add_flag('r')
+      assert_equal ['R', 'S'], @message.flags
 
-        # Test lowercase
-        @message.add_flag('r')
-        assert_equal ['R', 'S'], @message.flags
+      @message.remove_flag('S')
+      assert_equal ['R'], @message.flags
 
-        @message.remove_flag('S')
-        assert_equal ['R'], @message.flags
+      # Test lowercase
+      @message.remove_flag('r')
+      assert_equal [], @message.flags
+    end
 
-        # Test lowercase
-        @message.remove_flag('r')
-        assert_equal [], @message.flags
+    flag_tests = {
+      "FRS" => ['F', 'R', 'S'],
+      "Sr" => ['R', 'S'], # test capitalization & sorting
+      '' => []
+    }
+    flag_tests.each do |arg, results|
+      should "set flags: #{arg}" do
+        @message.flags = arg
+        assert_equal results, @message.flags
+        path_suffix = "#{Maildir::Message::INFO}#{results.join('')}"
+        assert_match /#{path_suffix}$/, @message.path
       end
+    end
+  end
 
-      flag_tests = {
-        "FRS" => ['F', 'R', 'S'],
-        "Sr" => ['R', 'S'], # test capitalization & sorting
-        '' => []
-      }
-      flag_tests.each do |arg, results|
-        should "set flags: #{arg}" do
-          @message.flags = arg
-          assert_equal results, @message.flags
-          path_suffix = "#{Maildir::Message::INFO}#{results.join('')}"
-          assert_match /#{path_suffix}$/, @message.path
-        end
-      end
-      context "when destroyed" do
-        setup { @message.destroy }
-        should "be frozen" do
-          assert @message.frozen?, "Message is not frozen"
-        end
-        should "have a nonexistant path" do
-          assert !File.exists?(@message.path), "Message path exists"
-        end
+  context "A destroyed message" do
+    setup do
+      FakeFS::FileSystem.clear
+      @message = Maildir::Message.create(temp_maildir, "foo")
+      @message.destroy
+    end
+    should "be frozen" do
+      assert @message.frozen?, "Message is not frozen"
+    end
+    should "have a nonexistant path" do
+      assert !File.exists?(@message.path), "Message path exists"
+    end
+  end
+
+  context "A message with a bad path" do
+    setup do
+      FakeFS::FileSystem.clear
+      @message = temp_maildir.add("")
+      File.delete(@message.path)
+    end
+
+    should "raise error for data" do
+      assert_raise Errno::ENOENT do
+        @message.data
       end
+      assert @message.frozen?
+    end
+
+    should "not be processed" do
+      old_key = @message.key
+      assert_equal false, @message.process
+      assert @message.frozen?
+    end
+
+
+    should "reset to the old key after attempt to process" do
+      old_key = @message.key
+      @message.process
+      assert_equal old_key, @message.key
     end
   end
 
-  context "Messages" do
+  context "Different messages" do
     setup do
-      @message1 = temp_maildir.add("")
+      FakeFS::FileSystem.clear
     end
-    
+
     should "differ" do
-      @message2 = Maildir::Message.new(temp_maildir)
+      @message1 = temp_maildir.add("")
+      @message2 = temp_maildir.add("")
       assert_equal -1, @message1 <=> @message2
       assert_equal 1,  @message2 <=> @message1
       assert_not_equal @message1, @message2
-      
     end
-    
+  end
+
+  context "Identical messages" do
+    setup do
+      FakeFS::FileSystem.clear
+    end
+
     should "be identical" do
+      @message1 = temp_maildir.add("")
       another_message1 = temp_maildir.get(@message1.key)
       assert_equal @message1, another_message1
     end
   end
 
+  context "Message#utime" do
+    setup do
+      FakeFS::FileSystem.clear
+    end
+
+    should "update the messages mtime" do
+      @message = temp_maildir.add("")
+      time = Time.now - 60
+
+      @message.utime(time, time)
+
+      # Time should be within 1 second of each other
+      assert_in_delta time, @message.mtime, 1
+    end
+
+    # atime not currently supported in FakeFS
+    # should "update the messages atime" do
+    #   @message = temp_maildir.add("")
+    #   time = Time.now - 60
+    #
+    #   @message.utime(time, time)
+    #
+    #   # Time should be within 1 second of each other
+    #   assert_in_delta time, @message.atime, 1
+    # end
+  end
 end

data/test/test_serializers.rb

@@ -1,11 +1,4 @@
 require 'test_helper'
-
-# Require all the serializers
-path = File.join(File.dirname(__FILE__), "..","lib","maildir","serializer","*")
-Dir.glob(path).each do |file|
-  require file
-end
-
 class TestSerializers < Test::Unit::TestCase
 
   serializers = [
@@ -18,6 +11,7 @@ class TestSerializers < Test::Unit::TestCase
   serializers.each do |klass, dumper|
     context "A message serialized with #{klass}" do
       setup do
+        FakeFS::FileSystem.clear
         @data = case klass.new
         when Maildir::Serializer::Mail
           Mail.new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: maildir
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Aaron Suggs
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-08 00:00:00 -05:00
+date: 2010-01-24 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,6 +42,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
+- !ruby/object:Gem::Dependency 
+  name: ktheory-fakefs
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: A ruby library for reading and writing arbitrary messages in DJB's maildir format
 email: aaron@ktheory.com
 executables: []
@@ -59,12 +69,14 @@ files:
 - VERSION
 - benchmarks/runner
 - lib/maildir.rb
+- lib/maildir/keywords.rb
 - lib/maildir/message.rb
 - lib/maildir/serializer/base.rb
 - lib/maildir/serializer/json.rb
 - lib/maildir/serializer/mail.rb
 - lib/maildir/serializer/marshal.rb
 - lib/maildir/serializer/yaml.rb
+- lib/maildir/subdirs.rb
 - lib/maildir/unique_name.rb
 - maildir.gemspec
 - test/test_helper.rb