nilclass-maildir 0.4.1

data/lib/maildir/serializer/base.rb

@@ -0,0 +1,20 @@
+module Maildir::Serializer
+  # The Maildir::Serializer::Base class reads & writes data to disk as a
+  # string. Other serializers (e.g. Maildir::Serializer::Mail) can extend this
+  # class to do some pre- and post-processing of the string.
+  #
+  # The Serializer API has two methods:
+  #   load(path) # => returns data
+  #   dump(data, path) # => returns number of bytes written
+  class Base
+    # Reads the file at path. Returns the contents of path.
+    def load(path)
+      File.read(path)
+    end
+
+    # Writes data to path. Returns number of bytes written.
+    def dump(data, path)
+      File.open(path, "w") {|file| file.write(data)}
+    end
+  end
+end

data/lib/maildir/serializer/json.rb

@@ -0,0 +1,13 @@
+require 'json'
+# Serialize messages as JSON
+class Maildir::Serializer::JSON < Maildir::Serializer::Base
+  # Read data from path and parse it as JSON.
+  def load(path)
+    ::JSON.load(super(path))
+  end
+
+  # Dump data as JSON and writes it to path.
+  def dump(data, path)
+    super(data.to_json, path)
+  end
+end

data/lib/maildir/serializer/mail.rb

@@ -0,0 +1,13 @@
+require 'mail'
+# Serialize messages as a ruby Mail object
+class Maildir::Serializer::Mail < Maildir::Serializer::Base
+  # Build a new Mail object from the data at path.
+  def load(path)
+    ::Mail.new(super(path))
+  end
+  
+  # Write data to path as a Mail message.
+  def dump(data, path)
+    super(data.to_s, path)
+  end
+end

data/lib/maildir/serializer/marshal.rb

@@ -0,0 +1,12 @@
+# Serialize messages as Marshalled ruby objects
+class Maildir::Serializer::Marshal < Maildir::Serializer::Base
+  # Read data from path and unmarshal it.
+  def load(path)
+    ::Marshal.load(super(path))
+  end
+
+  # Marshal data and write it to path.
+  def dump(data, path)
+    super(::Marshal.dump(data), path)
+  end
+end

data/lib/maildir/serializer/yaml.rb

@@ -0,0 +1,13 @@
+require 'yaml'
+# Serialize messages as YAML
+class Maildir::Serializer::YAML < Maildir::Serializer::Base
+  # Read data from path and parse it as YAML.
+  def load(path)
+    ::YAML.load(super(path))
+  end
+
+  # Dump data as YAML and writes it to path.
+  def dump(data, path)
+    super(data.to_yaml, path)
+  end
+end

data/lib/maildir/subdirs.rb

@@ -0,0 +1,70 @@
+# 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 name
+    root? ? ROOT_NAME : subdir_parts(path).last
+  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)
+    path.sub!(/\/$/, '') # remove trailing slash
+    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/lib/maildir/unique_name.rb

@@ -0,0 +1,72 @@
+# Class for generating unique file names for new messages
+class Maildir::UniqueName
+  require 'thread' # For mutex support
+  require 'socket' # For getting the hostname
+  class << self
+    # Return a thread-safe increasing counter
+    def counter
+      @counter_mutex ||= Mutex.new
+      @counter_mutex.synchronize do
+        @counter = @counter.to_i + 1
+      end
+    end
+
+    def create
+      self.new.to_s
+    end
+  end
+
+  # Return a unique file name based on strategy
+  def initialize
+    # Use the same time object
+    @now = Time.now
+  end
+
+  # Return the name as a string
+  def to_s
+    [left, middle, right].join(".")
+  end
+
+  protected
+  # The left part of the unique name is the number of seconds from since the
+  # UNIX epoch
+  def left
+    @now.to_i.to_s
+  end
+
+  # The middle part contains the microsecond, the process id, and a
+  # per-process incrementing counter
+  def middle
+    "M#{microsecond}P#{process_id}Q#{delivery_count}"
+  end
+
+  # The right part is the hostname
+  def right
+    Socket.gethostname
+  end
+
+  def secure_random(bytes=8)
+    # File.read("/dev/urandom", bytes).unpack("H*")[0]
+    raise "Not implemented"
+  end
+
+  def inode
+    raise "Not implemented"
+  end
+
+  def device_number
+    raise "Not implemented"
+  end
+
+  def microsecond
+    @now.usec.to_s
+  end
+
+  def process_id
+    Process.pid.to_s
+  end
+
+  def delivery_count
+    self.class.counter.to_s
+  end
+end

data/maildir.gemspec

@@ -0,0 +1,81 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{maildir}
+  s.version = "0.4.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aaron Suggs", "Niklas E. Cathor"]
+  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 = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "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",
+     "test/test_keywords.rb",
+     "test/test_maildir.rb",
+     "test/test_message.rb",
+     "test/test_serializers.rb",
+     "test/test_subdirs.rb",
+     "test/test_unique_name.rb"
+  ]
+  s.homepage = %q{http://github.com/ktheory/maildir}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Read & write messages in the maildir format}
+  s.test_files = [
+    "test/test_serializers.rb",
+     "test/test_keywords.rb",
+     "test/test_helper.rb",
+     "test/test_subdirs.rb",
+     "test/test_message.rb",
+     "test/test_unique_name.rb",
+     "test/test_maildir.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      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

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+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
+    Maildir.new("/tmp/maildir_test")
+end
+
+# create the subdir tree:
+# | INBOX
+# |-- a
+# | |-- x
+# | |-- y
+# |-- b
+def setup_subdirs(maildir)
+  %w(a b a.x a.y).each do |x|
+    Maildir.new(File.join(maildir.path, ".#{x}"))
+  end
+end
+
+# Useful for testing that strings defined & not empty
+def assert_not_empty(obj, msg='')
+  assert !obj.nil? && !obj.empty?, msg
+end

data/test/test_keywords.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+require 'maildir/keywords'
+class TestKeywords < Test::Unit::TestCase
+  context "A message" do 
+    setup do 
+      @data = "foo\n"
+      @msg = Maildir::Message.create(temp_maildir, @data)
+    end
+
+    should "remember keywords" do 
+      kw = %w(Junk Seen)
+      @msg.keywords = kw
+      assert (@msg.keywords & kw).size == 2
+    end
+  end
+end

data/test/test_maildir.rb

@@ -0,0 +1,73 @@
+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
+
+    should "create subdirectories by default" do
+      %w(tmp new cur).each do |subdir|
+        subdir_path = temp_maildir.send("#{subdir}_path")
+        assert File.directory?(subdir_path), "Subdir #{subdir} does not exist"
+      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
+      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
+    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
+
+    should "list a new message" do
+      @message = temp_maildir.add("")
+      messages = temp_maildir.list(:new)
+      assert messages.include?(@message)
+    end
+
+    should "list a cur message" do
+      @message = temp_maildir.add("")
+      @message.process
+      messages = temp_maildir.list(:cur)
+      assert messages.include?(@message)
+    end
+  end
+
+  context "Maildirs with the same path" do
+    should "be identical" do
+      another_maildir = Maildir.new(temp_maildir.path, false)
+      assert_equal temp_maildir, another_maildir
+    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

@@ -0,0 +1,226 @@
+require 'test_helper'
+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 in :tmp" do
+      assert_equal :tmp, @message.dir
+      assert_match(/tmp/, @message.path)
+    end
+
+    should "have a unique name" do
+      assert_not_empty @message.unique_name
+    end
+
+    should "have a file name" do
+      assert_not_empty @message.filename
+    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
+    end
+  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
+    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
+    end
+
+    should "be in new" do
+      assert_equal :new, @message.dir
+      assert_match(/new/, @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
+  end
+
+  context "A processed message" do
+    setup do
+      FakeFS::FileSystem.clear
+      @data = "foo"
+      @message = Maildir::Message.create(temp_maildir, @data)
+      @message.process
+    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 "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 "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
+
+      @message.remove_flag('S')
+      assert_equal ['R'], @message.flags
+
+      # Test lowercase
+      @message.remove_flag('r')
+      assert_equal [], @message.flags
+    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
+  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 "Different messages" do
+    setup do
+      FakeFS::FileSystem.clear
+    end
+
+    should "differ" do
+      @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